Re-land "Remove NOTIFICATION_FULLSCREEN_CHANGED"

This re-lands commit a5646d5a.

Difference to original:

Override TearDownOnMainThread() instead of TearDown().

Original change's description:
> Remove NOTIFICATION_FULLSCREEN_CHANGED
>
> Replace with an observer interface on FullscreenController.
>
> Bug: 268984
> Change-Id: I1af2056e870af56b2f436a3aa8c6a54ed0ff44fb
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1666148
> Reviewed-by: Scott Violet <sky@chromium.org>
> Commit-Queue: Evan Stade <estade@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#671901}

Bug: 268984
Change-Id: I735754efa634d8ef21b4bb57f366dbad22b3c682
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1676731
Commit-Queue: Evan Stade <estade@chromium.org>
Reviewed-by: Scott Violet <sky@chromium.org>
Cr-Commit-Position: refs/heads/master@{#673412}

chrome/browser/chrome_notification_types.h

@@ -317,9 +317,6 @@ enum NotificationType {
   // Sent when a ProtocolHandlerRegistry is changed. The source is the profile.
   NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED,
 
-  // Sent when the browser enters or exits fullscreen mode.
-  NOTIFICATION_FULLSCREEN_CHANGED,
-
   // Sent when the FullscreenController changes, confirms, or denies mouse lock.
   // The source is the browser's FullscreenController, no details.
   NOTIFICATION_MOUSE_LOCK_CHANGED,

chrome/browser/chromeos/login/lock/screen_locker_browsertest.cc

@@ -35,23 +35,6 @@ namespace {
 
 constexpr char kFingerprint[] = "pinky";
 
-class FullscreenWaiter {
- public:
-  explicit FullscreenWaiter(Browser* browser) : browser_(browser) {}
-  ~FullscreenWaiter() = default;
-
-  void WaitForState(bool fullscreen) {
-    if (browser_->window()->IsFullscreen() != fullscreen)
-      observer_.Wait();
-  }
-
- private:
-  FullscreenNotificationObserver observer_;
-  Browser* browser_;
-
-  DISALLOW_COPY_AND_ASSIGN(FullscreenWaiter);
-};
-
 class ScreenLockerTest : public InProcessBrowserTest {
  public:
   ScreenLockerTest() = default;
@@ -144,20 +127,18 @@ IN_PROC_BROWSER_TEST_F(ScreenLockerTest, TestFullscreenExit) {
   ash::wm::WindowState* window_state =
       ash::wm::GetWindowState(browser_window->GetNativeWindow());
   {
-    FullscreenWaiter fullscreen_waiter(browser());
+    FullscreenNotificationObserver fullscreen_waiter(browser());
     browser()
         ->exclusive_access_manager()
         ->fullscreen_controller()
         ->ToggleBrowserFullscreenMode();
-    fullscreen_waiter.WaitForState(true);
+    fullscreen_waiter.Wait();
     EXPECT_TRUE(browser_window->IsFullscreen());
     EXPECT_FALSE(window_state->GetHideShelfWhenFullscreen());
     EXPECT_FALSE(tester.IsLocked());
   }
   {
-    FullscreenWaiter fullscreen_waiter(browser());
     tester.Lock();
-    fullscreen_waiter.WaitForState(true);
     EXPECT_TRUE(browser_window->IsFullscreen());
     EXPECT_FALSE(window_state->GetHideShelfWhenFullscreen());
     EXPECT_TRUE(tester.IsLocked());
@@ -166,12 +147,12 @@ IN_PROC_BROWSER_TEST_F(ScreenLockerTest, TestFullscreenExit) {
   tester.UnlockWithPassword(user_manager::StubAccountId(), "pass");
   EXPECT_FALSE(tester.IsLocked());
   {
-    FullscreenWaiter fullscreen_waiter(browser());
+    FullscreenNotificationObserver fullscreen_waiter(browser());
     browser()
         ->exclusive_access_manager()
         ->fullscreen_controller()
         ->ToggleBrowserFullscreenMode();
-    fullscreen_waiter.WaitForState(false);
+    fullscreen_waiter.Wait();
     EXPECT_FALSE(browser_window->IsFullscreen());
   }
 
@@ -183,22 +164,20 @@ IN_PROC_BROWSER_TEST_F(ScreenLockerTest, TestFullscreenExit) {
   // has all of the pixels, locking the screen should exit fullscreen. The
   // fullscreen window has all of the pixels when in tab fullscreen.
   {
-    FullscreenWaiter fullscreen_waiter(browser());
+    FullscreenNotificationObserver fullscreen_waiter(browser());
     content::WebContents* web_contents =
         browser()->tab_strip_model()->GetActiveWebContents();
     browser()
         ->exclusive_access_manager()
         ->fullscreen_controller()
         ->EnterFullscreenModeForTab(web_contents, GURL());
-    fullscreen_waiter.WaitForState(true);
+    fullscreen_waiter.Wait();
     EXPECT_TRUE(browser_window->IsFullscreen());
     EXPECT_TRUE(window_state->GetHideShelfWhenFullscreen());
     EXPECT_FALSE(tester.IsLocked());
   }
   {
-    FullscreenWaiter fullscreen_waiter(browser());
     tester.Lock();
-    fullscreen_waiter.WaitForState(false);
     EXPECT_FALSE(browser_window->IsFullscreen());
     EXPECT_TRUE(tester.IsLocked());
   }

chrome/browser/site_isolation/site_per_process_interactive_browsertest.cc

@@ -686,11 +686,10 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessInteractiveBrowserTest,
   AddResizeListener(child, GetScreenSize());
   {
     content::DOMMessageQueue queue;
-    std::unique_ptr<FullscreenNotificationObserver> observer(
-        new FullscreenNotificationObserver());
+    FullscreenNotificationObserver observer(browser());
     EXPECT_TRUE(ExecuteScript(child, "activateFullscreen()"));
     WaitForMultipleFullscreenEvents(expected_events, queue);
-    observer->Wait();
+    observer.Wait();
   }
 
   // Verify that the browser has entered fullscreen for the current tab.
@@ -722,11 +721,10 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessInteractiveBrowserTest,
   AddResizeListener(child, original_child_size);
   {
     content::DOMMessageQueue queue;
-    std::unique_ptr<FullscreenNotificationObserver> observer(
-        new FullscreenNotificationObserver());
+    FullscreenNotificationObserver observer(browser());
     EXPECT_TRUE(ExecuteScript(child, "exitFullscreen()"));
     WaitForMultipleFullscreenEvents(expected_events, queue);
-    observer->Wait();
+    observer.Wait();
   }
 
   EXPECT_FALSE(browser()->window()->IsFullscreen());
@@ -786,11 +784,10 @@ void SitePerProcessInteractiveBrowserTest::FullscreenElementInABA(
   std::set<std::string> expected_events = {"main_frame", "child", "grandchild"};
   {
     content::DOMMessageQueue queue;
-    std::unique_ptr<FullscreenNotificationObserver> observer(
-        new FullscreenNotificationObserver());
+    FullscreenNotificationObserver observer(browser());
     EXPECT_TRUE(ExecuteScript(grandchild, "activateFullscreen()"));
     WaitForMultipleFullscreenEvents(expected_events, queue);
-    observer->Wait();
+    observer.Wait();
   }
 
   // Verify that the browser has entered fullscreen for the current tab.
@@ -817,8 +814,7 @@ void SitePerProcessInteractiveBrowserTest::FullscreenElementInABA(
   AddResizeListener(grandchild, original_grandchild_size);
   {
     content::DOMMessageQueue queue;
-    std::unique_ptr<FullscreenNotificationObserver> observer(
-        new FullscreenNotificationObserver());
+    FullscreenNotificationObserver observer(browser());
     switch (exit_method) {
       case FullscreenExitMethod::JS_CALL:
         EXPECT_TRUE(ExecuteScript(grandchild, "exitFullscreen()"));
@@ -831,7 +827,7 @@ void SitePerProcessInteractiveBrowserTest::FullscreenElementInABA(
         NOTREACHED();
     }
     WaitForMultipleFullscreenEvents(expected_events, queue);
-    observer->Wait();
+    observer.Wait();
   }
 
   EXPECT_FALSE(browser()->window()->IsFullscreen());
@@ -950,11 +946,10 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessInteractiveBrowserTest,
   // browser finishes the fullscreen transition.
   {
     content::DOMMessageQueue queue;
-    std::unique_ptr<FullscreenNotificationObserver> observer(
-        new FullscreenNotificationObserver());
+    FullscreenNotificationObserver observer(browser());
     EXPECT_TRUE(ExecuteScript(c_middle, "activateFullscreen()"));
     WaitForMultipleFullscreenEvents(expected_events, queue);
-    observer->Wait();
+    observer.Wait();
   }
 
   // Verify that the browser has entered fullscreen for the current tab.
@@ -991,12 +986,11 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessInteractiveBrowserTest,
   AddResizeListener(c_middle, c_middle_original_size);
   {
     content::DOMMessageQueue queue;
-    std::unique_ptr<FullscreenNotificationObserver> observer(
-        new FullscreenNotificationObserver());
+    FullscreenNotificationObserver observer(browser());
     ASSERT_TRUE(ui_test_utils::SendKeyPressSync(browser(), ui::VKEY_ESCAPE,
                                                 false, false, false, false));
     WaitForMultipleFullscreenEvents(expected_events, queue);
-    observer->Wait();
+    observer.Wait();
   }
 
   EXPECT_FALSE(browser()->window()->IsFullscreen());

chrome/browser/ui/BUILD.gn

@@ -886,7 +886,6 @@ jumbo_split_static_library("ui") {
       "exclusive_access/exclusive_access_bubble_hide_callback.h",
       "exclusive_access/exclusive_access_bubble_type.cc",
       "exclusive_access/exclusive_access_bubble_type.h",
-      "exclusive_access/exclusive_access_context.cc",
       "exclusive_access/exclusive_access_context.h",
       "exclusive_access/exclusive_access_controller_base.cc",
       "exclusive_access/exclusive_access_controller_base.h",
@@ -894,6 +893,7 @@ jumbo_split_static_library("ui") {
       "exclusive_access/exclusive_access_manager.h",
       "exclusive_access/fullscreen_controller.cc",
       "exclusive_access/fullscreen_controller.h",
+      "exclusive_access/fullscreen_observer.h",
       "exclusive_access/fullscreen_within_tab_helper.cc",
       "exclusive_access/fullscreen_within_tab_helper.h",
       "exclusive_access/keyboard_lock_controller.cc",

chrome/browser/ui/cocoa/permission_bubble/permission_bubble_views_cocoa_browsertest.mm

@@ -48,21 +48,28 @@ IN_PROC_BROWSER_TEST_F(PermissionBubbleBrowserTest, HasLocationBarByDefault) {
 }
 
 IN_PROC_BROWSER_TEST_F(PermissionBubbleBrowserTest,
-                       TabFullscreenHasLocationBar) {
-  FullscreenNotificationObserver fullscreen_observer;
+                       TabFullscreenHasNoLocationBar) {
   ShowBubble(browser());
   EXPECT_TRUE(HasVisibleLocationBarForBrowser(browser()));
 
   FullscreenController* controller =
       browser()->exclusive_access_manager()->fullscreen_controller();
-  controller->EnterFullscreenModeForTab(
-      browser()->tab_strip_model()->GetActiveWebContents(), GURL());
-  fullscreen_observer.Wait();
+  {
+    FullscreenNotificationObserver fullscreen_observer(browser());
+    controller->EnterFullscreenModeForTab(
+        browser()->tab_strip_model()->GetActiveWebContents(), GURL());
+    fullscreen_observer.Wait();
+  }
+  EXPECT_TRUE(controller->IsTabFullscreen());
   EXPECT_FALSE(HasVisibleLocationBarForBrowser(browser()));
 
-  controller->ExitFullscreenModeForTab(
-      browser()->tab_strip_model()->GetActiveWebContents());
-  fullscreen_observer.Wait();
+  {
+    FullscreenNotificationObserver fullscreen_observer(browser());
+    controller->ExitFullscreenModeForTab(
+        browser()->tab_strip_model()->GetActiveWebContents());
+    fullscreen_observer.Wait();
+  }
+  EXPECT_FALSE(controller->IsTabFullscreen());
   EXPECT_TRUE(HasVisibleLocationBarForBrowser(browser()));
 }
 

chrome/browser/ui/exclusive_access/exclusive_access_context.cc

-// Copyright (c) 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "chrome/browser/ui/exclusive_access/exclusive_access_context.h"
-
-#include "base/logging.h"
-#include "build/build_config.h"
-
-// This file provides default implementations for the ExclusiveAccessContext
-// methods that only some platforms care about.
-
-void ExclusiveAccessContext::UpdateUIForTabFullscreen(
-    TabFullscreenState state) {
-  NOTIMPLEMENTED();
-}
-
-void ExclusiveAccessContext::UpdateFullscreenToolbar() {
-  NOTIMPLEMENTED();
-}

chrome/browser/ui/exclusive_access/exclusive_access_context.h

@@ -26,7 +26,7 @@ class ExclusiveAccessContext {
     STATE_EXIT_TAB_FULLSCREEN,
   };
 
-  virtual ~ExclusiveAccessContext() {}
+  virtual ~ExclusiveAccessContext() = default;
 
   // Returns the current profile associated with the window.
   virtual Profile* GetProfile() = 0;
@@ -38,11 +38,11 @@ class ExclusiveAccessContext {
   // Called when we transition between tab and browser fullscreen. This method
   // updates the UI by showing/hiding the tab strip, toolbar and bookmark bar
   // in the browser fullscreen. Currently only supported on Mac.
-  virtual void UpdateUIForTabFullscreen(TabFullscreenState state);
+  virtual void UpdateUIForTabFullscreen(TabFullscreenState state) {}
 
   // Updates the toolbar state to be hidden or shown in fullscreen according to
   // the preference's state. Only supported on Mac.
-  virtual void UpdateFullscreenToolbar();
+  virtual void UpdateFullscreenToolbar() {}
 
   // Enters fullscreen and update exit bubble.
   virtual void EnterFullscreen(const GURL& url,

chrome/browser/ui/exclusive_access/fullscreen_controller.cc

@@ -13,7 +13,6 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
-#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/exclusive_access/exclusive_access_context.h"
@@ -26,7 +25,6 @@
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
-#include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
@@ -49,16 +47,16 @@ const char kFullscreenBubbleReshowsHistogramName[] =
 }  // namespace
 
 FullscreenController::FullscreenController(ExclusiveAccessManager* manager)
-    : ExclusiveAccessControllerBase(manager),
-      state_prior_to_tab_fullscreen_(STATE_INVALID),
-      tab_fullscreen_(false),
-      toggled_into_fullscreen_(false),
-      deactivated_contents_(nullptr),
-      is_privileged_fullscreen_for_testing_(false),
-      is_tab_fullscreen_for_testing_(false),
-      ptr_factory_(this) {}
+    : ExclusiveAccessControllerBase(manager) {}
 
-FullscreenController::~FullscreenController() {
+FullscreenController::~FullscreenController() = default;
+
+void FullscreenController::AddObserver(FullscreenObserver* observer) {
+  observer_list_.AddObserver(observer);
+}
+
+void FullscreenController::RemoveObserver(FullscreenObserver* observer) {
+  observer_list_.RemoveObserver(observer);
 }
 
 bool FullscreenController::IsFullscreenForBrowser() const {
@@ -162,7 +160,7 @@ void FullscreenController::EnterFullscreenModeForTab(WebContents* web_contents,
 
   // This is only a change between Browser and Tab fullscreen. We generate
   // a fullscreen notification now because there is no window change.
-  PostFullscreenChangeNotification(true);
+  PostFullscreenChangeNotification();
 }
 
 void FullscreenController::ExitFullscreenModeForTab(WebContents* web_contents) {
@@ -208,7 +206,7 @@ void FullscreenController::ExitFullscreenModeForTab(WebContents* web_contents) {
 
   // This is only a change between Browser and Tab fullscreen. We generate
   // a fullscreen notification now because there is no window change.
-  PostFullscreenChangeNotification(true);
+  PostFullscreenChangeNotification();
 }
 
 void FullscreenController::OnTabDeactivated(
@@ -273,7 +271,7 @@ void FullscreenController::WindowFullscreenStateChanged() {
       exclusive_access_manager()->context();
   bool exiting_fullscreen = !exclusive_access_context->IsFullscreen();
 
-  PostFullscreenChangeNotification(!exiting_fullscreen);
+  PostFullscreenChangeNotification();
   if (exiting_fullscreen) {
     toggled_into_fullscreen_ = false;
     extension_caused_fullscreen_ = GURL();
@@ -317,18 +315,15 @@ void FullscreenController::ExitExclusiveAccessIfNecessary() {
     NotifyTabExclusiveAccessLost();
 }
 
-void FullscreenController::PostFullscreenChangeNotification(
-    bool is_fullscreen) {
+void FullscreenController::PostFullscreenChangeNotification() {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::BindOnce(&FullscreenController::NotifyFullscreenChange,
-                                ptr_factory_.GetWeakPtr(), is_fullscreen));
+                                ptr_factory_.GetWeakPtr()));
 }
 
-void FullscreenController::NotifyFullscreenChange(bool is_fullscreen) {
-  content::NotificationService::current()->Notify(
-      chrome::NOTIFICATION_FULLSCREEN_CHANGED,
-      content::Source<FullscreenController>(this),
-      content::Details<bool>(&is_fullscreen));
+void FullscreenController::NotifyFullscreenChange() {
+  for (auto& observer : observer_list_)
+    observer.OnFullscreenStateChanged();
 }
 
 void FullscreenController::NotifyTabExclusiveAccessLost() {

chrome/browser/ui/exclusive_access/fullscreen_controller.h

@@ -9,11 +9,10 @@
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
-#include "build/build_config.h"
+#include "base/observer_list.h"
 #include "chrome/browser/ui/exclusive_access/exclusive_access_controller_base.h"
+#include "chrome/browser/ui/exclusive_access/fullscreen_observer.h"
 #include "components/content_settings/core/common/content_settings.h"
-#include "content/public/browser/notification_observer.h"
-#include "content/public/browser/notification_registrar.h"
 
 class GURL;
 
@@ -63,6 +62,9 @@ class FullscreenController : public ExclusiveAccessControllerBase {
   explicit FullscreenController(ExclusiveAccessManager* manager);
   ~FullscreenController() override;
 
+  void AddObserver(FullscreenObserver* observer);
+  void RemoveObserver(FullscreenObserver* observer);
+
   // Browser/User Fullscreen ///////////////////////////////////////////////////
 
   // Returns true if the window is currently fullscreen and was initially
@@ -156,10 +158,9 @@ class FullscreenController : public ExclusiveAccessControllerBase {
     TAB
   };
 
-  // Posts a task to call NotifyFullscreenChange.
-  void PostFullscreenChangeNotification(bool is_fullscreen);
-  // Sends a NOTIFICATION_FULLSCREEN_CHANGED notification.
-  void NotifyFullscreenChange(bool is_fullscreen);
+  // Posts a task to notify observers of the fullscreen state change.
+  void PostFullscreenChangeNotification();
+  void NotifyFullscreenChange();
 
   // Notifies the tab that it has been forced out of fullscreen mode if
   // necessary.
@@ -198,25 +199,27 @@ class FullscreenController : public ExclusiveAccessControllerBase {
   };
   // The state before entering tab fullscreen mode via webkitRequestFullScreen.
   // When not in tab fullscreen, it is STATE_INVALID.
-  PriorFullscreenState state_prior_to_tab_fullscreen_;
+  PriorFullscreenState state_prior_to_tab_fullscreen_ = STATE_INVALID;
   // True if the site has entered into fullscreen.
-  bool tab_fullscreen_;
+  bool tab_fullscreen_ = false;
 
   // True if this controller has toggled into tab OR browser fullscreen.
-  bool toggled_into_fullscreen_;
+  bool toggled_into_fullscreen_ = false;
 
   // Set in OnTabDeactivated(). Used to see if we're in the middle of
   // deactivation of a tab.
-  content::WebContents* deactivated_contents_;
+  content::WebContents* deactivated_contents_ = nullptr;
 
   // Used in testing to confirm proper behavior for specific, privileged
   // fullscreen cases.
-  bool is_privileged_fullscreen_for_testing_;
+  bool is_privileged_fullscreen_for_testing_ = false;
 
   // Used in testing to set the state to tab fullscreen.
-  bool is_tab_fullscreen_for_testing_;
+  bool is_tab_fullscreen_for_testing_ = false;
+
+  base::ObserverList<FullscreenObserver> observer_list_;
 
-  base::WeakPtrFactory<FullscreenController> ptr_factory_;
+  base::WeakPtrFactory<FullscreenController> ptr_factory_{this};
 
   DISALLOW_COPY_AND_ASSIGN(FullscreenController);
 };

chrome/browser/ui/exclusive_access/fullscreen_controller_interactive_browsertest.cc

@@ -90,7 +90,7 @@ void FullscreenControllerInteractiveTest::ToggleTabFullscreenNoRetries(
 void FullscreenControllerInteractiveTest::ToggleBrowserFullscreen(
     bool enter_fullscreen) {
   ASSERT_EQ(browser()->window()->IsFullscreen(), !enter_fullscreen);
-  FullscreenNotificationObserver fullscreen_observer;
+  FullscreenNotificationObserver fullscreen_observer(browser());
 
   chrome::ToggleFullscreenMode(browser());
 
@@ -103,7 +103,7 @@ void FullscreenControllerInteractiveTest::ToggleTabFullscreen_Internal(
     bool enter_fullscreen, bool retry_until_success) {
   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
   do {
-    FullscreenNotificationObserver fullscreen_observer;
+    FullscreenNotificationObserver fullscreen_observer(browser());
     if (enter_fullscreen)
       browser()->EnterFullscreenModeForTab(tab, GURL(),
                                            blink::WebFullscreenOptions());
@@ -133,7 +133,7 @@ IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest,
   ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreen(true));
 
   {
-    FullscreenNotificationObserver fullscreen_observer;
+    FullscreenNotificationObserver fullscreen_observer(browser());
     AddTabAtIndex(1, GURL(url::kAboutBlankURL), PAGE_TRANSITION_TYPED);
     fullscreen_observer.Wait();
     ASSERT_FALSE(browser()->window()->IsFullscreen());
@@ -264,7 +264,7 @@ IN_PROC_BROWSER_TEST_F(
   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
 
   {
-    FullscreenNotificationObserver fullscreen_observer;
+    FullscreenNotificationObserver fullscreen_observer(browser());
     EXPECT_FALSE(browser()->window()->IsFullscreen());
     browser()->EnterFullscreenModeForTab(tab, GURL(),
                                          blink::WebFullscreenOptions());
@@ -273,7 +273,7 @@ IN_PROC_BROWSER_TEST_F(
   }
 
   {
-    FullscreenNotificationObserver fullscreen_observer;
+    FullscreenNotificationObserver fullscreen_observer(browser());
     chrome::ToggleFullscreenMode(browser());
     fullscreen_observer.Wait();
     EXPECT_FALSE(browser()->window()->IsFullscreen());
@@ -282,7 +282,7 @@ IN_PROC_BROWSER_TEST_F(
   {
     // Test that tab fullscreen mode doesn't make presentation mode the default
     // on Lion.
-    FullscreenNotificationObserver fullscreen_observer;
+    FullscreenNotificationObserver fullscreen_observer(browser());
     chrome::ToggleFullscreenMode(browser());
     fullscreen_observer.Wait();
     EXPECT_TRUE(browser()->window()->IsFullscreen());
@@ -328,7 +328,7 @@ IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest,
 
   // Request to lock the mouse and enter fullscreen.
   {
-    FullscreenNotificationObserver fullscreen_observer;
+    FullscreenNotificationObserver fullscreen_observer(browser());
     ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait(
         browser(), ui::VKEY_B, false, true, false, false,
         chrome::NOTIFICATION_MOUSE_LOCK_CHANGED,
@@ -338,7 +338,7 @@ IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest,
 
   // Escape, no prompts should remain.
   {
-    FullscreenNotificationObserver fullscreen_observer;
+    FullscreenNotificationObserver fullscreen_observer(browser());
     SendEscapeToFullscreenController();
     fullscreen_observer.Wait();
   }
@@ -401,7 +401,7 @@ IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest,
 
   // Request to lock the mouse and enter fullscreen.
   {
-    FullscreenNotificationObserver fullscreen_observer;
+    FullscreenNotificationObserver fullscreen_observer(browser());
     ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait(
         browser(), ui::VKEY_B, false, true, false, false,
         chrome::NOTIFICATION_MOUSE_LOCK_CHANGED,
@@ -427,7 +427,7 @@ IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest,
   SetPrivilegedFullscreen(true);
 
   // Request to lock the mouse and enter fullscreen.
-  FullscreenNotificationObserver fullscreen_observer;
+  FullscreenNotificationObserver fullscreen_observer(browser());
   ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait(
       browser(), ui::VKEY_B, false, true, false, false,
       chrome::NOTIFICATION_MOUSE_LOCK_CHANGED,
@@ -639,7 +639,7 @@ IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest,
 
   // Request to lock the mouse and enter fullscreen.
   {
-    FullscreenNotificationObserver fullscreen_observer;
+    FullscreenNotificationObserver fullscreen_observer(browser());
     ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait(
         browser(), ui::VKEY_B, false, true, false, false,
         chrome::NOTIFICATION_MOUSE_LOCK_CHANGED,
@@ -652,7 +652,7 @@ IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest,
 
   // Reload. Mouse should be unlocked and fullscreen exited.
   {
-    FullscreenNotificationObserver fullscreen_observer;
+    FullscreenNotificationObserver fullscreen_observer(browser());
     Reload();
     fullscreen_observer.Wait();
     ASSERT_FALSE(IsMouseLocked());

chrome/browser/ui/exclusive_access/fullscreen_controller_state_interactive_browsertest.cc

@@ -31,15 +31,26 @@
 class FullscreenControllerStateInteractiveTest
     : public InProcessBrowserTest,
       public FullscreenControllerStateTest {
- private:
-  // FullscreenControllerStateTest override:
-  Browser* GetBrowser() override;
-};
+ public:
+  FullscreenControllerStateInteractiveTest() = default;
+  ~FullscreenControllerStateInteractiveTest() override = default;
+
+  // InProcessBrowserTest:
+  void TearDownOnMainThread() override {
+    // This code needs to override TearDownOnMainThread() as that is called
+    // before the Browser created by BrowserTestBase is deleted. TearDown() is
+    // called after the browser has already been deleted, which means the test
+    // code tries to remove an observer from a browser that was destroyed.
+    FullscreenControllerStateTest::TearDown();
+    InProcessBrowserTest::TearDownOnMainThread();
+  }
 
-Browser* FullscreenControllerStateInteractiveTest::GetBrowser() {
-  return InProcessBrowserTest::browser();
-}
+  // FullscreenControllerStateTest:
+  Browser* GetBrowser() override { return InProcessBrowserTest::browser(); }
 
+ private:
+  DISALLOW_COPY_AND_ASSIGN(FullscreenControllerStateInteractiveTest);
+};
 
 // Soak tests ------------------------------------------------------------------
 

chrome/browser/ui/exclusive_access/fullscreen_controller_state_test.cc

@@ -227,12 +227,12 @@ const char* FullscreenControllerStateTest::GetWindowStateString() {
 
 bool FullscreenControllerStateTest::InvokeEvent(Event event) {
   if (!fullscreen_notification_observer_.get()) {
-    // Start observing NOTIFICATION_FULLSCREEN_CHANGED. Construct the
-    // notification observer here instead of in
+    // Start observing fullscreen changes. Construct the notification observer
+    // here instead of in
     // FullscreenControllerStateTest::FullscreenControllerStateTest() so that we
     // listen to notifications on the proper thread.
-    fullscreen_notification_observer_.reset(
-        new FullscreenNotificationObserver());
+    fullscreen_notification_observer_ =
+        std::make_unique<FullscreenNotificationObserver>(GetBrowser());
   }
 
   State source_state = state_;
@@ -350,8 +350,8 @@ void FullscreenControllerStateTest::MaybeWaitForNotification() {
       IsPersistentState(state_)) {
     fullscreen_notification_observer_->Wait();
     last_notification_received_state_ = state_;
-    fullscreen_notification_observer_.reset(
-        new FullscreenNotificationObserver());
+    fullscreen_notification_observer_ =
+        std::make_unique<FullscreenNotificationObserver>(GetBrowser());
   }
 }
 
@@ -507,6 +507,10 @@ void FullscreenControllerStateTest::VerifyWindowStateExpectations(
   }
 }
 
+void FullscreenControllerStateTest::TearDown() {
+  fullscreen_notification_observer_.reset();
+}
+
 FullscreenController* FullscreenControllerStateTest::GetFullscreenController() {
   return GetBrowser()->exclusive_access_manager()->fullscreen_controller();
 }

chrome/browser/ui/exclusive_access/fullscreen_controller_state_test.h

@@ -100,8 +100,8 @@ class FullscreenControllerStateTest {
   // Checks that window state matches the expected controller state.
   virtual void VerifyWindowState();
 
-  // Wait for NOTIFICATION_FULLSCREEN_CHANGED if a notification should have been
-  // sent in transitioning to |state_| from the previous persistent state.
+  // Wait for a fullscreen change if a notification should have been sent in
+  // transitioning to |state_| from the previous persistent state.
   void MaybeWaitForNotification();
 
   // Tests all states with all permutations of multiple events to detect
@@ -165,6 +165,8 @@ class FullscreenControllerStateTest {
       FullscreenForBrowserExpectation fullscreen_for_browser,
       FullscreenForTabExpectation fullscreen_for_tab);
 
+  void TearDown();
+
   virtual Browser* GetBrowser() = 0;
   FullscreenController* GetFullscreenController();
 

chrome/browser/ui/exclusive_access/fullscreen_controller_state_unittest.cc

@@ -216,6 +216,7 @@ class FullscreenControllerStateUnitTest : public BrowserWithTestWindowTest,
 
   // FullscreenControllerStateTest:
   void SetUp() override;
+  void TearDown() override;
   std::unique_ptr<BrowserWindow> CreateBrowserWindow() override;
   void ChangeWindowFullscreenState() override;
   const char* GetWindowStateString() override;
@@ -225,18 +226,24 @@ class FullscreenControllerStateUnitTest : public BrowserWithTestWindowTest,
   // FullscreenControllerStateTest:
   bool ShouldSkipStateAndEventPair(State state, Event event) override;
   Browser* GetBrowser() override;
-  FullscreenControllerTestWindow* window_;
+  FullscreenControllerTestWindow* window_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(FullscreenControllerStateUnitTest);
 };
 
-FullscreenControllerStateUnitTest::FullscreenControllerStateUnitTest()
-    : window_(NULL) {
-}
+FullscreenControllerStateUnitTest::FullscreenControllerStateUnitTest() =
+    default;
 
 void FullscreenControllerStateUnitTest::SetUp() {
   BrowserWithTestWindowTest::SetUp();
   window_->set_browser(browser());
 }
 
+void FullscreenControllerStateUnitTest::TearDown() {
+  FullscreenControllerStateTest::TearDown();
+  BrowserWithTestWindowTest::TearDown();
+}
+
 std::unique_ptr<BrowserWindow>
 FullscreenControllerStateUnitTest::CreateBrowserWindow() {
   auto window = std::make_unique<FullscreenControllerTestWindow>();

chrome/browser/ui/exclusive_access/fullscreen_controller_test.cc

@@ -33,6 +33,26 @@
 
 using content::WebContents;
 
+FullscreenNotificationObserver::FullscreenNotificationObserver(
+    Browser* browser) {
+  observer_.Add(browser->exclusive_access_manager()->fullscreen_controller());
+}
+
+FullscreenNotificationObserver::~FullscreenNotificationObserver() = default;
+
+void FullscreenNotificationObserver::OnFullscreenStateChanged() {
+  observed_change_ = true;
+  if (run_loop_.running())
+    run_loop_.Quit();
+}
+
+void FullscreenNotificationObserver::Wait() {
+  if (observed_change_)
+    return;
+
+  run_loop_.Run();
+}
+
 const char FullscreenControllerTest::kFullscreenKeyboardLockHTML[] =
     "/fullscreen_keyboardlock/fullscreen_keyboardlock.html";
 
@@ -173,20 +193,20 @@ void FullscreenControllerTest::SetPrivilegedFullscreen(bool is_privileged) {
 
 void FullscreenControllerTest::EnterActiveTabFullscreen() {
   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
-  FullscreenNotificationObserver fullscreen_observer;
+  FullscreenNotificationObserver fullscreen_observer(browser());
   browser()->EnterFullscreenModeForTab(tab, GURL(),
                                        blink::WebFullscreenOptions());
   fullscreen_observer.Wait();
 }
 
 void FullscreenControllerTest::ToggleBrowserFullscreen() {
-  FullscreenNotificationObserver fullscreen_observer;
+  FullscreenNotificationObserver fullscreen_observer(browser());
   chrome::ToggleFullscreenMode(browser());
   fullscreen_observer.Wait();
 }
 
 void FullscreenControllerTest::EnterExtensionInitiatedFullscreen() {
-  FullscreenNotificationObserver fullscreen_observer;
+  FullscreenNotificationObserver fullscreen_observer(browser());
   browser()->ToggleFullscreenModeWithExtension(GURL("faux_extension"));
   fullscreen_observer.Wait();
 }

chrome/browser/ui/exclusive_access/fullscreen_controller_test.h

@@ -10,12 +10,15 @@
 #include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
+#include "base/run_loop.h"
+#include "base/scoped_observer.h"
 #include "base/test/scoped_feature_list.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/ui/exclusive_access/exclusive_access_bubble_hide_callback.h"
 #include "chrome/browser/ui/exclusive_access/exclusive_access_bubble_type.h"
 #include "chrome/browser/ui/exclusive_access/fullscreen_controller.h"
+#include "chrome/browser/ui/exclusive_access/fullscreen_observer.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/test/test_utils.h"
@@ -24,18 +27,30 @@
 #include "ui/base/test/scoped_fake_nswindow_fullscreen.h"
 #endif
 
+class Browser;
+
 namespace base {
 class TickClock;
 }  // namespace base
 
-// Observer for NOTIFICATION_FULLSCREEN_CHANGED notifications.
-class FullscreenNotificationObserver
-    : public content::WindowedNotificationObserver {
+// Observer for fullscreen state change notifications.
+class FullscreenNotificationObserver : public FullscreenObserver {
  public:
-  FullscreenNotificationObserver() : WindowedNotificationObserver(
-      chrome::NOTIFICATION_FULLSCREEN_CHANGED,
-      content::NotificationService::AllSources()) {}
+  explicit FullscreenNotificationObserver(Browser* browser);
+  ~FullscreenNotificationObserver() override;
+
+  // Runs a loop until a fullscreen change is seen (unless one has already been
+  // observed, in which case it returns immediately).
+  void Wait();
+
+  // FullscreenObserver:
+  void OnFullscreenStateChanged() override;
+
  protected:
+  bool observed_change_ = false;
+  ScopedObserver<FullscreenController, FullscreenObserver> observer_{this};
+  base::RunLoop run_loop_;
+
   DISALLOW_COPY_AND_ASSIGN(FullscreenNotificationObserver);
 };
 

chrome/browser/ui/exclusive_access/fullscreen_observer.h

+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_UI_EXCLUSIVE_ACCESS_FULLSCREEN_OBSERVER_H_
+#define CHROME_BROWSER_UI_EXCLUSIVE_ACCESS_FULLSCREEN_OBSERVER_H_
+
+#include "base/observer_list_types.h"
+
+// An interface to be notified of changes in FullscreenController.
+class FullscreenObserver : public base::CheckedObserver {
+ public:
+  virtual void OnFullscreenStateChanged() = 0;
+};
+
+#endif  // CHROME_BROWSER_UI_EXCLUSIVE_ACCESS_FULLSCREEN_OBSERVER_H_

chrome/browser/ui/fullscreen_keyboard_browsertest_base.cc

@@ -11,14 +11,13 @@
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "chrome/app/chrome_command_ids.h"
-#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_list.h"
+#include "chrome/browser/ui/exclusive_access/fullscreen_controller_test.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/interactive_test_utils.h"
-#include "content/public/browser/notification_service.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
@@ -181,9 +180,7 @@ void FullscreenKeyboardBrowserTestBase::SendShiftShortcut(
 void FullscreenKeyboardBrowserTestBase::SendFullscreenShortcutAndWait() {
   // On MacOSX, entering and exiting fullscreen are not synchronous. So we wait
   // for the observer to notice the change of fullscreen state.
-  content::WindowedNotificationObserver observer(
-      chrome::NOTIFICATION_FULLSCREEN_CHANGED,
-      content::NotificationService::AllSources());
+  FullscreenNotificationObserver observer(GetActiveBrowser());
 // Enter fullscreen.
 #if defined(OS_MACOSX)
   // On MACOSX, Command + Control + F is used.
@@ -202,16 +199,14 @@ void FullscreenKeyboardBrowserTestBase::SendFullscreenShortcutAndWait() {
 // keyboard events. As a result, content doesn't actually know it has entered
 // fullscreen. For more details, see ScopedFakeNSWindowFullscreen.
 // TODO(crbug.com/837438): Remove this once ScopedFakeNSWindowFullscreen fires
-// NOTIFICATION_FULLSCREEN_CHANGED.
+// OnFullscreenStateChanged.
 #if !defined(OS_MACOSX)
   observer.Wait();
 #endif
 }
 
 void FullscreenKeyboardBrowserTestBase::SendJsFullscreenShortcutAndWait() {
-  content::WindowedNotificationObserver observer(
-      chrome::NOTIFICATION_FULLSCREEN_CHANGED,
-      content::NotificationService::AllSources());
+  FullscreenNotificationObserver observer(GetActiveBrowser());
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(GetActiveBrowser(), ui::VKEY_S,
                                               false, false, false, false));
   expected_result_ += "KeyS ctrl:false shift:false alt:false meta:false\n";
@@ -227,9 +222,7 @@ void FullscreenKeyboardBrowserTestBase::SendEscape() {
 
 void FullscreenKeyboardBrowserTestBase::
     SendEscapeAndWaitForExitingFullscreen() {
-  content::WindowedNotificationObserver observer(
-      chrome::NOTIFICATION_FULLSCREEN_CHANGED,
-      content::NotificationService::AllSources());
+  FullscreenNotificationObserver observer(GetActiveBrowser());
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
       GetActiveBrowser(), ui::VKEY_ESCAPE, false, false, false, false));
   observer.Wait();

chrome/browser/ui/views/exclusive_access_bubble_views.cc

@@ -14,7 +14,6 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/app/chrome_command_ids.h"
-#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/ui/exclusive_access/exclusive_access_manager.h"
 #include "chrome/browser/ui/exclusive_access/fullscreen_controller.h"
 #include "chrome/browser/ui/views/exclusive_access_bubble_views_context.h"
@@ -22,7 +21,6 @@
 #include "chrome/browser/ui/views/frame/top_container_view.h"
 #include "chrome/browser/ui/views/subtle_notification_view.h"
 #include "chrome/grit/generated_resources.h"
-#include "content/public/browser/notification_service.h"
 #include "ui/accessibility/ax_node_data.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/events/keycodes/keyboard_codes.h"
@@ -70,10 +68,8 @@ ExclusiveAccessBubbleViews::ExclusiveAccessBubbleViews(
   view_->SetBounds(0, 0, size.width(), size.height());
   popup_->AddObserver(this);
 
-  registrar_.Add(this, chrome::NOTIFICATION_FULLSCREEN_CHANGED,
-                 content::Source<FullscreenController>(
-                     bubble_view_context_->GetExclusiveAccessManager()
-                         ->fullscreen_controller()));
+  fullscreen_observer_.Add(bubble_view_context_->GetExclusiveAccessManager()
+                               ->fullscreen_controller());
 
   UpdateMouseWatcher();
 }
@@ -275,11 +271,7 @@ bool ExclusiveAccessBubbleViews::CanTriggerOnMouse() const {
   return bubble_view_context_->CanTriggerOnMouse();
 }
 
-void ExclusiveAccessBubbleViews::Observe(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
-  DCHECK_EQ(chrome::NOTIFICATION_FULLSCREEN_CHANGED, type);
+void ExclusiveAccessBubbleViews::OnFullscreenStateChanged() {
   UpdateMouseWatcher();
 }
 

chrome/browser/ui/views/exclusive_access_bubble_views.h

@@ -9,10 +9,11 @@
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
+#include "base/scoped_observer.h"
 #include "chrome/browser/ui/exclusive_access/exclusive_access_bubble.h"
 #include "chrome/browser/ui/exclusive_access/exclusive_access_bubble_hide_callback.h"
-#include "content/public/browser/notification_observer.h"
-#include "content/public/browser/notification_registrar.h"
+#include "chrome/browser/ui/exclusive_access/fullscreen_controller.h"
+#include "chrome/browser/ui/exclusive_access/fullscreen_observer.h"
 #include "ui/views/widget/widget_observer.h"
 
 class ExclusiveAccessBubbleViewsContext;
@@ -32,7 +33,7 @@ class SubtleNotificationView;
 // a click target. The bubble auto-hides, and re-shows when the user moves to
 // the screen top.
 class ExclusiveAccessBubbleViews : public ExclusiveAccessBubble,
-                                   public content::NotificationObserver,
+                                   public FullscreenObserver,
                                    public views::WidgetObserver {
  public:
   ExclusiveAccessBubbleViews(
@@ -84,10 +85,8 @@ class ExclusiveAccessBubbleViews : public ExclusiveAccessBubble,
   bool IsAnimating() override;
   bool CanTriggerOnMouse() const override;
 
-  // content::NotificationObserver:
-  void Observe(int type,
-               const content::NotificationSource& source,
-               const content::NotificationDetails& details) override;
+  // FullscreenObserver:
+  void OnFullscreenStateChanged() override;
 
   // views::WidgetObserver:
   void OnWidgetDestroyed(views::Widget* widget) override;
@@ -111,7 +110,8 @@ class ExclusiveAccessBubbleViews : public ExclusiveAccessBubble,
   SubtleNotificationView* view_;
   base::string16 browser_fullscreen_exit_accelerator_;
 
-  content::NotificationRegistrar registrar_;
+  ScopedObserver<FullscreenController, FullscreenObserver> fullscreen_observer_{
+      this};
 
   DISALLOW_COPY_AND_ASSIGN(ExclusiveAccessBubbleViews);
 };

chrome/browser/ui/views/frame/browser_non_client_frame_view_ash_browsertest.cc

@@ -98,7 +98,7 @@ namespace {
 
 // Toggles fullscreen mode and waits for the notification.
 void ToggleFullscreenModeAndWait(Browser* browser) {
-  FullscreenNotificationObserver waiter;
+  FullscreenNotificationObserver waiter(browser);
   chrome::ToggleFullscreenMode(browser);
   waiter.Wait();
 }
@@ -106,7 +106,7 @@ void ToggleFullscreenModeAndWait(Browser* browser) {
 // Enters fullscreen mode for tab and waits for the notification.
 void EnterFullscreenModeForTabAndWait(Browser* browser,
                                       content::WebContents* web_contents) {
-  FullscreenNotificationObserver waiter;
+  FullscreenNotificationObserver waiter(browser);
   browser->exclusive_access_manager()
       ->fullscreen_controller()
       ->EnterFullscreenModeForTab(web_contents, GURL());
@@ -116,20 +116,13 @@ void EnterFullscreenModeForTabAndWait(Browser* browser,
 // Exits fullscreen mode for tab and waits for the notification.
 void ExitFullscreenModeForTabAndWait(Browser* browser,
                                      content::WebContents* web_contents) {
-  FullscreenNotificationObserver waiter;
+  FullscreenNotificationObserver waiter(browser);
   browser->exclusive_access_manager()
       ->fullscreen_controller()
       ->ExitFullscreenModeForTab(web_contents);
   waiter.Wait();
 }
 
-// Exits fullscreen mode and waits for the notification.
-void ExitFullscreenModeAndWait(BrowserView* browser_view) {
-  FullscreenNotificationObserver waiter;
-  browser_view->ExitFullscreen();
-  waiter.Wait();
-}
-
 void StartOverview() {
   ash::Shell::Get()->overview_controller()->StartOverview();
 }
@@ -490,7 +483,11 @@ IN_PROC_BROWSER_TEST_P(ImmersiveModeBrowserViewTest, ImmersiveFullscreen) {
 
   // Exiting immersive fullscreen should make the caption buttons and the frame
   // visible again.
-  ExitFullscreenModeAndWait(browser_view);
+  {
+    FullscreenNotificationObserver waiter(browser());
+    browser_view->ExitFullscreen();
+    waiter.Wait();
+  }
   EXPECT_FALSE(immersive_mode_controller->IsEnabled());
   EXPECT_TRUE(frame_view->ShouldPaint());
   EXPECT_LT(0, frame_view->GetBoundsForTabStripRegion(browser_view->tabstrip())

chrome/browser/ui/views/frame/hosted_app_ash_interactive_ui_test.cc

@@ -5,6 +5,7 @@
 #include "ash/public/cpp/immersive/immersive_fullscreen_controller_test_api.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/ui/browser_commands.h"
+#include "chrome/browser/ui/exclusive_access/exclusive_access_manager.h"
 #include "chrome/browser/ui/exclusive_access/fullscreen_controller_test.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/frame/hosted_app_button_container.h"
@@ -71,7 +72,7 @@ IN_PROC_BROWSER_TEST_F(HostedAppAshInteractiveUITest, MenuButtonClickable) {
 // Test that the hosted app menu button opens a menu on click in immersive mode.
 IN_PROC_BROWSER_TEST_F(HostedAppAshInteractiveUITest,
                        ImmersiveMenuButtonClickable) {
-  FullscreenNotificationObserver waiter;
+  FullscreenNotificationObserver waiter(browser());
   chrome::ToggleFullscreenMode(browser());
   waiter.Wait();
 

chrome/browser/ui/views/frame/immersive_mode_controller_ash.cc

@@ -7,15 +7,12 @@
 #include "ash/public/cpp/immersive/immersive_revealed_lock.h"
 #include "ash/public/cpp/window_properties.h"
 #include "base/macros.h"
-#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/ui/ash/tablet_mode_client.h"
 #include "chrome/browser/ui/exclusive_access/exclusive_access_manager.h"
-#include "chrome/browser/ui/exclusive_access/fullscreen_controller.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/frame/top_container_view.h"
 #include "chrome/browser/ui/views/tabs/tab_strip.h"
-#include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
@@ -83,12 +80,10 @@ void ImmersiveModeControllerAsh::SetEnabled(bool enabled) {
   if (controller_.IsEnabled() == enabled)
     return;
 
-  if (registrar_.IsEmpty()) {
-    content::Source<FullscreenController> source(
-        browser_view_->browser()
-            ->exclusive_access_manager()
-            ->fullscreen_controller());
-    registrar_.Add(this, chrome::NOTIFICATION_FULLSCREEN_CHANGED, source);
+  if (!fullscreen_observer_.IsObservingSources()) {
+    fullscreen_observer_.Add(browser_view_->browser()
+                                 ->exclusive_access_manager()
+                                 ->fullscreen_controller());
   }
 
   ash::ImmersiveFullscreenController::EnableForWidget(browser_view_->frame(),
@@ -221,16 +216,14 @@ std::vector<gfx::Rect> ImmersiveModeControllerAsh::GetVisibleBoundsInScreen()
   return bounds_in_screen;
 }
 
-void ImmersiveModeControllerAsh::Observe(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
-  DCHECK_EQ(chrome::NOTIFICATION_FULLSCREEN_CHANGED, type);
+void ImmersiveModeControllerAsh::OnFullscreenStateChanged() {
   if (!controller_.IsEnabled())
     return;
 
   // Auto hide the shelf in immersive browser fullscreen.
-  bool in_tab_fullscreen = content::Source<FullscreenController>(source)
+  bool in_tab_fullscreen = browser_view_->browser()
+                               ->exclusive_access_manager()
+                               ->fullscreen_controller()
                                ->IsWindowFullscreenForTabOrPending();
   browser_view_->GetNativeWindow()->SetProperty(
       ash::kHideShelfWhenFullscreenKey, in_tab_fullscreen);

chrome/browser/ui/views/frame/immersive_mode_controller_ash.h

@@ -11,9 +11,9 @@
 #include "ash/public/cpp/immersive/immersive_fullscreen_controller_delegate.h"
 #include "base/macros.h"
 #include "base/scoped_observer.h"
+#include "chrome/browser/ui/exclusive_access/fullscreen_controller.h"
+#include "chrome/browser/ui/exclusive_access/fullscreen_observer.h"
 #include "chrome/browser/ui/views/frame/immersive_mode_controller.h"
-#include "content/public/browser/notification_observer.h"
-#include "content/public/browser/notification_registrar.h"
 #include "ui/aura/window_observer.h"
 #include "ui/gfx/geometry/rect.h"
 
@@ -24,7 +24,7 @@ class Window;
 class ImmersiveModeControllerAsh
     : public ImmersiveModeController,
       public ash::ImmersiveFullscreenControllerDelegate,
-      public content::NotificationObserver,
+      public FullscreenObserver,
       public aura::WindowObserver {
  public:
   ImmersiveModeControllerAsh();
@@ -59,12 +59,10 @@ class ImmersiveModeControllerAsh
   void SetVisibleFraction(double visible_fraction) override;
   std::vector<gfx::Rect> GetVisibleBoundsInScreen() const override;
 
-  // content::NotificationObserver override:
-  void Observe(int type,
-               const content::NotificationSource& source,
-               const content::NotificationDetails& details) override;
+  // FullscreenObserver:
+  void OnFullscreenStateChanged() override;
 
-  // aura::WindowObserver override:
+  // aura::WindowObserver:
   void OnWindowPropertyChanged(aura::Window* window,
                                const void* key,
                                intptr_t old) override;
@@ -82,7 +80,8 @@ class ImmersiveModeControllerAsh
   // the top-of-window views are not revealed.
   double visible_fraction_ = 1.0;
 
-  content::NotificationRegistrar registrar_;
+  ScopedObserver<FullscreenController, FullscreenObserver> fullscreen_observer_{
+      this};
 
   ScopedObserver<aura::Window, aura::WindowObserver> observed_windows_{this};
 

chrome/browser/ui/views/frame/immersive_mode_controller_ash_browsertest.cc

@@ -11,6 +11,7 @@
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "chrome/browser/ui/ash/tablet_mode_client.h"
 #include "chrome/browser/ui/browser_commands.h"
+#include "chrome/browser/ui/exclusive_access/exclusive_access_manager.h"
 #include "chrome/browser/ui/exclusive_access/fullscreen_controller.h"
 #include "chrome/browser/ui/exclusive_access/fullscreen_controller_test.h"
 #include "chrome/browser/ui/views/frame/browser_non_client_frame_view.h"
@@ -24,11 +25,8 @@
 #include "chrome/browser/ui/views/toolbar/toolbar_view.h"
 #include "chrome/common/web_application_info.h"
 #include "chrome/test/base/ui_test_utils.h"
-#include "content/public/common/content_switches.h"
-#include "content/public/common/service_manager_connection.h"
 #include "content/public/test/content_mock_cert_verifier.h"
 #include "net/cert/mock_cert_verifier.h"
-#include "services/service_manager/public/cpp/connector.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/views/animation/test/ink_drop_host_view_test_api.h"
 #include "ui/views/window/frame_caption_button.h"
@@ -97,12 +95,12 @@ class ImmersiveModeControllerAshHostedAppBrowserTest
 
   // Toggle the browser's fullscreen state.
   void ToggleFullscreen() {
-    // NOTIFICATION_FULLSCREEN_CHANGED is sent asynchronously. The notification
-    // is used to trigger changes in whether the shelf is auto hidden.
-    std::unique_ptr<FullscreenNotificationObserver> waiter(
-        new FullscreenNotificationObserver());
+    // The fullscreen change notification is sent asynchronously. The
+    // notification is used to trigger changes in whether the shelf is auto
+    // hidden.
+    FullscreenNotificationObserver waiter(browser());
     chrome::ToggleFullscreenMode(browser());
-    waiter->Wait();
+    waiter.Wait();
   }
 
   // Attempt revealing the top-of-window views.

chrome/browser/ui/views/frame/immersive_mode_controller_ash_unittest.cc

@@ -54,22 +54,20 @@ class ImmersiveModeControllerAshTest : public TestWithBrowserView {
 
   // Toggle the browser's fullscreen state.
   void ToggleFullscreen() {
-    // NOTIFICATION_FULLSCREEN_CHANGED is sent asynchronously. The notification
-    // is used to trigger changes in whether the shelf is auto hidden and
-    // whether a "light bar" version of the tab strip is used when the
-    // top-of-window views are hidden.
-    std::unique_ptr<FullscreenNotificationObserver> waiter(
-        new FullscreenNotificationObserver());
+    // The fullscreen change notification is sent asynchronously. The
+    // notification is used to trigger changes in whether the shelf is auto
+    // hidden and whether a "light bar" version of the tab strip is used when
+    // the top-of-window views are hidden.
+    FullscreenNotificationObserver waiter(browser());
     chrome::ToggleFullscreenMode(browser());
-    waiter->Wait();
+    waiter.Wait();
   }
 
   // Set whether the browser is in tab fullscreen.
   void SetTabFullscreen(bool tab_fullscreen) {
     content::WebContents* web_contents =
         browser_view()->contents_web_view()->GetWebContents();
-    std::unique_ptr<FullscreenNotificationObserver> waiter(
-        new FullscreenNotificationObserver());
+    FullscreenNotificationObserver waiter(browser());
     if (tab_fullscreen) {
       browser()
           ->exclusive_access_manager()
@@ -81,7 +79,7 @@ class ImmersiveModeControllerAshTest : public TestWithBrowserView {
           ->fullscreen_controller()
           ->ExitFullscreenModeForTab(web_contents);
     }
-    waiter->Wait();
+    waiter.Wait();
   }
 
   // Attempt revealing the top-of-window views.

chrome/browser/ui/views/fullscreen_control/fullscreen_control_view_interactive_uitest.cc

@@ -12,16 +12,15 @@
 #include "base/test/scoped_feature_list.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
-#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/ui/exclusive_access/exclusive_access_bubble_type.h"
 #include "chrome/browser/ui/exclusive_access/exclusive_access_manager.h"
+#include "chrome/browser/ui/exclusive_access/fullscreen_controller_test.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/fullscreen_control/fullscreen_control_host.h"
 #include "chrome/browser/ui/views/fullscreen_control/fullscreen_control_view.h"
 #include "chrome/common/chrome_features.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
-#include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_features.h"
 #include "content/public/test/browser_test_utils.h"
@@ -44,19 +43,6 @@ namespace {
 
 constexpr base::TimeDelta kPopupEventTimeout = base::TimeDelta::FromSeconds(5);
 
-// Observer for NOTIFICATION_FULLSCREEN_CHANGED notifications.
-class FullscreenNotificationObserver
-    : public content::WindowedNotificationObserver {
- public:
-  FullscreenNotificationObserver()
-      : WindowedNotificationObserver(
-            chrome::NOTIFICATION_FULLSCREEN_CHANGED,
-            content::NotificationService::AllSources()) {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(FullscreenNotificationObserver);
-};
-
 }  // namespace
 
 class FullscreenControlViewTest : public InProcessBrowserTest {
@@ -120,7 +106,7 @@ class FullscreenControlViewTest : public InProcessBrowserTest {
   bool IsPopupCreated() { return GetFullscreenControlHost()->IsPopupCreated(); }
 
   void EnterActiveTabFullscreen() {
-    FullscreenNotificationObserver fullscreen_observer;
+    FullscreenNotificationObserver fullscreen_observer(browser());
     content::WebContentsDelegate* delegate =
         static_cast<content::WebContentsDelegate*>(browser());
     delegate->EnterFullscreenModeForTab(GetActiveWebContents(),

chrome/browser/ui/views/location_bar/location_bar_bubble_delegate_view.cc

@@ -5,13 +5,10 @@
 #include "chrome/browser/ui/views/location_bar/location_bar_bubble_delegate_view.h"
 
 #include "build/build_config.h"
-#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
-#include "chrome/browser/ui/exclusive_access/fullscreen_controller.h"
 #include "chrome/browser/ui/layout_constants.h"
 #include "chrome/grit/generated_resources.h"
-#include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_view_host.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/geometry/rect.h"
@@ -52,10 +49,8 @@ LocationBarBubbleDelegateView::LocationBarBubbleDelegateView(
   // Add observer to close the bubble if the fullscreen state changes.
   if (web_contents) {
     Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
-    registrar_.Add(
-        this, chrome::NOTIFICATION_FULLSCREEN_CHANGED,
-        content::Source<FullscreenController>(
-            browser->exclusive_access_manager()->fullscreen_controller()));
+    fullscreen_observer_.Add(
+        browser->exclusive_access_manager()->fullscreen_controller());
   }
   if (!anchor_view)
     SetAnchorRect(gfx::Rect(anchor_point, gfx::Size()));
@@ -86,11 +81,7 @@ void LocationBarBubbleDelegateView::ShowForReason(DisplayReason reason,
   }
 }
 
-void LocationBarBubbleDelegateView::Observe(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
-  DCHECK_EQ(chrome::NOTIFICATION_FULLSCREEN_CHANGED, type);
+void LocationBarBubbleDelegateView::OnFullscreenStateChanged() {
   GetWidget()->SetVisibilityAnimationTransition(views::Widget::ANIMATE_NONE);
   CloseBubble();
 }

chrome/browser/ui/views/location_bar/location_bar_bubble_delegate_view.h

@@ -6,16 +6,15 @@
 #define CHROME_BROWSER_UI_VIEWS_LOCATION_BAR_LOCATION_BAR_BUBBLE_DELEGATE_VIEW_H_
 
 #include "base/macros.h"
-#include "content/public/browser/notification_observer.h"
-#include "content/public/browser/notification_registrar.h"
+#include "base/scoped_observer.h"
+#include "chrome/browser/ui/exclusive_access/fullscreen_controller.h"
+#include "chrome/browser/ui/exclusive_access/fullscreen_observer.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "ui/events/event_observer.h"
 #include "ui/views/bubble/bubble_dialog_delegate_view.h"
 #include "ui/views/event_monitor.h"
 
 namespace content {
-class NotificationDetails;
-class NotificationSource;
 class WebContents;
 }  // namespace content
 
@@ -24,7 +23,7 @@ class WebContents;
 // mode.
 // TODO(https://crbug.com/788051): Move to chrome/browser/ui/views/page_action/.
 class LocationBarBubbleDelegateView : public views::BubbleDialogDelegateView,
-                                      public content::NotificationObserver,
+                                      public FullscreenObserver,
                                       public content::WebContentsObserver {
  public:
   enum DisplayReason {
@@ -56,10 +55,8 @@ class LocationBarBubbleDelegateView : public views::BubbleDialogDelegateView,
   // user).
   void ShowForReason(DisplayReason reason, bool allow_refocus_alert = true);
 
-  // content::NotificationObserver:
-  void Observe(int type,
-               const content::NotificationSource& source,
-               const content::NotificationDetails& details) override;
+  // FullscreenObserver:
+  void OnFullscreenStateChanged() override;
 
   // content::WebContentsObserver:
   void OnVisibilityChanged(content::Visibility visibility) override;
@@ -99,8 +96,8 @@ class LocationBarBubbleDelegateView : public views::BubbleDialogDelegateView,
   virtual void CloseBubble();
 
  private:
-  // Used to register for fullscreen change notifications.
-  content::NotificationRegistrar registrar_;
+  ScopedObserver<FullscreenController, FullscreenObserver> fullscreen_observer_{
+      this};
 
   DISALLOW_COPY_AND_ASSIGN(LocationBarBubbleDelegateView);
 };

chrome/browser/ui/views/location_bar/zoom_bubble_view_browsertest.cc

@@ -62,15 +62,14 @@ IN_PROC_BROWSER_TEST_F(ZoomBubbleBrowserTest, NonImmersiveFullscreen) {
   // Entering fullscreen should close the bubble. (We enter into tab fullscreen
   // here because tab fullscreen is non-immersive even on Chrome OS.)
   {
-    // NOTIFICATION_FULLSCREEN_CHANGED is sent asynchronously. Wait for the
+    // The fullscreen change notification is sent asynchronously. Wait for the
     // notification before testing the zoom bubble visibility.
-    std::unique_ptr<FullscreenNotificationObserver> waiter(
-        new FullscreenNotificationObserver());
+    FullscreenNotificationObserver waiter(browser());
     browser()
         ->exclusive_access_manager()
         ->fullscreen_controller()
         ->EnterFullscreenModeForTab(web_contents, GURL());
-    waiter->Wait();
+    waiter.Wait();
   }
   ASSERT_FALSE(browser_view->immersive_mode_controller()->IsEnabled());
   EXPECT_FALSE(ZoomBubbleView::GetZoomBubble());
@@ -85,10 +84,9 @@ IN_PROC_BROWSER_TEST_F(ZoomBubbleBrowserTest, NonImmersiveFullscreen) {
 
   // Exit fullscreen before ending the test for the sake of sanity.
   {
-    std::unique_ptr<FullscreenNotificationObserver> waiter(
-        new FullscreenNotificationObserver());
+    FullscreenNotificationObserver waiter(browser());
     chrome::ToggleFullscreenMode(browser());
-    waiter->Wait();
+    waiter.Wait();
   }
 }
 
@@ -108,10 +106,9 @@ IN_PROC_BROWSER_TEST_F(ZoomBubbleBrowserTest, ImmersiveFullscreen) {
 
   // Enter immersive fullscreen.
   {
-    std::unique_ptr<FullscreenNotificationObserver> waiter(
-        new FullscreenNotificationObserver());
+    FullscreenNotificationObserver waiter(browser());
     chrome::ToggleFullscreenMode(browser());
-    waiter->Wait();
+    waiter.Wait();
   }
   ASSERT_TRUE(immersive_controller->IsEnabled());
   ASSERT_FALSE(immersive_controller->IsRevealed());
@@ -151,10 +148,9 @@ IN_PROC_BROWSER_TEST_F(ZoomBubbleBrowserTest, ImmersiveFullscreen) {
 
   // Exit fullscreen before ending the test for the sake of sanity.
   {
-    std::unique_ptr<FullscreenNotificationObserver> waiter(
-        new FullscreenNotificationObserver());
+    FullscreenNotificationObserver waiter(browser());
     chrome::ToggleFullscreenMode(browser());
-    waiter->Wait();
+    waiter.Wait();
   }
 }
 #endif  // OS_CHROMEOS

chrome/test/data/chromeos/oobe_webui_browsertest.js

@@ -34,9 +34,9 @@ OobeWebUITest.prototype = {
   /** @override */
   testGenPreamble: function() {
     // OobeWebUI should run in fullscreen.
-    GEN('  FullscreenNotificationObserver fullscreen_observer;');
-    GEN('  chrome::ToggleFullscreenMode(browser());');
-    GEN('  fullscreen_observer.Wait();');
+    GEN('FullscreenNotificationObserver fullscreen_observer(browser());');
+    GEN('chrome::ToggleFullscreenMode(browser());');
+    GEN('fullscreen_observer.Wait();');
   },
 
   /** @override */