Combine ImmersiveFocusWatcher{Mus,Classic}.

Use of TransientWindowClient and ActivationClient allow the same
implementation to work in both classic and Mash.

Bug: 640365
Change-Id: I10324dce04bb014c09d04f45c0be6e691017a648
Reviewed-on: https://chromium-review.googlesource.com/c/1271403Reviewed-by: Scott Violet <sky@chromium.org>
Reviewed-by: James Cook <jamescook@chromium.org>
Commit-Queue: Evan Stade <estade@chromium.org>
Cr-Commit-Position: refs/heads/master@{#600119}

ash/BUILD.gn

@@ -1141,8 +1141,6 @@ component("ash") {
     "wm/gestures/overview_gesture_handler.h",
     "wm/immersive_context_ash.cc",
     "wm/immersive_context_ash.h",
-    "wm/immersive_focus_watcher_classic.cc",
-    "wm/immersive_focus_watcher_classic.h",
     "wm/immersive_gesture_handler_classic.cc",
     "wm/immersive_gesture_handler_classic.h",
     "wm/immersive_handler_factory_ash.cc",

ash/public/cpp/BUILD.gn

@@ -70,6 +70,7 @@ component("cpp") {
     "frame_utils.h",
     "gesture_action_type.h",
     "immersive/immersive_context.h",
+    "immersive/immersive_focus_watcher.cc",
     "immersive/immersive_focus_watcher.h",
     "immersive/immersive_fullscreen_controller.cc",
     "immersive/immersive_fullscreen_controller.h",
@@ -135,6 +136,7 @@ component("cpp") {
     "//ui/views",
     "//ui/views/mus",
     "//ui/wm",
+    "//ui/wm/public",
   ]
 
   public_deps = [

ash/wm/immersive_focus_watcher_classic.cc → ash/public/cpp/immersive/immersive_focus_watcher.cc

-// Copyright 2016 The Chromium Authors. All rights reserved.
+// Copyright 2018 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 "ash/wm/immersive_focus_watcher_classic.h"
+#include "ash/public/cpp/immersive/immersive_focus_watcher.h"
 
 #include "ash/public/cpp/immersive/immersive_fullscreen_controller.h"
+#include "ui/aura/client/transient_window_client.h"
 #include "ui/aura/window.h"
 #include "ui/views/bubble/bubble_dialog_delegate_view.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
-#include "ui/wm/core/transient_window_manager.h"
-#include "ui/wm/core/window_util.h"
 #include "ui/wm/public/activation_client.h"
 
 namespace ash {
+
 namespace {
 
 // Returns the BubbleDialogDelegateView corresponding to |maybe_bubble| if
@@ -40,8 +40,10 @@ bool IsWindowTransientChildOf(aura::Window* maybe_transient,
   if (!maybe_transient || !toplevel)
     return false;
 
+  aura::client::TransientWindowClient* transient_window_client =
+      aura::client::GetTransientWindowClient();
   for (aura::Window* window = maybe_transient; window;
-       window = ::wm::GetTransientParent(window)) {
+       window = transient_window_client->GetTransientParent(window)) {
     if (window == toplevel)
       return true;
   }
@@ -60,8 +62,7 @@ bool IsWindowTransientChildOf(aura::Window* maybe_transient,
 // so that bubbles which are not activatable and bubbles which do not close
 // upon deactivation also keep the top-of-window views revealed for the
 // duration of their visibility.
-class ImmersiveFocusWatcherClassic::BubbleObserver
-    : public aura::WindowObserver {
+class ImmersiveFocusWatcher::BubbleObserver : public aura::WindowObserver {
  public:
   explicit BubbleObserver(ImmersiveFullscreenController* controller);
   ~BubbleObserver() override;
@@ -89,16 +90,16 @@ class ImmersiveFocusWatcherClassic::BubbleObserver
   DISALLOW_COPY_AND_ASSIGN(BubbleObserver);
 };
 
-ImmersiveFocusWatcherClassic::BubbleObserver::BubbleObserver(
+ImmersiveFocusWatcher::BubbleObserver::BubbleObserver(
     ImmersiveFullscreenController* controller)
     : controller_(controller) {}
 
-ImmersiveFocusWatcherClassic::BubbleObserver::~BubbleObserver() {
+ImmersiveFocusWatcher::BubbleObserver::~BubbleObserver() {
   for (aura::Window* bubble : bubbles_)
     bubble->RemoveObserver(this);
 }
 
-void ImmersiveFocusWatcherClassic::BubbleObserver::StartObserving(
+void ImmersiveFocusWatcher::BubbleObserver::StartObserving(
     aura::Window* bubble) {
   if (bubbles_.insert(bubble).second) {
     bubble->AddObserver(this);
@@ -106,7 +107,7 @@ void ImmersiveFocusWatcherClassic::BubbleObserver::StartObserving(
   }
 }
 
-void ImmersiveFocusWatcherClassic::BubbleObserver::StopObserving(
+void ImmersiveFocusWatcher::BubbleObserver::StopObserving(
     aura::Window* bubble) {
   if (bubbles_.erase(bubble)) {
     bubble->RemoveObserver(this);
@@ -114,7 +115,7 @@ void ImmersiveFocusWatcherClassic::BubbleObserver::StopObserving(
   }
 }
 
-void ImmersiveFocusWatcherClassic::BubbleObserver::UpdateRevealedLock() {
+void ImmersiveFocusWatcher::BubbleObserver::UpdateRevealedLock() {
   bool has_visible_bubble = false;
   for (aura::Window* bubble : bubbles_) {
     if (bubble->IsVisible()) {
@@ -147,35 +148,37 @@ void ImmersiveFocusWatcherClassic::BubbleObserver::UpdateRevealedLock() {
   }
 }
 
-void ImmersiveFocusWatcherClassic::BubbleObserver::OnWindowVisibilityChanged(
+void ImmersiveFocusWatcher::BubbleObserver::OnWindowVisibilityChanged(
     aura::Window*,
     bool visible) {
   UpdateRevealedLock();
 }
 
-void ImmersiveFocusWatcherClassic::BubbleObserver::OnWindowDestroying(
+void ImmersiveFocusWatcher::BubbleObserver::OnWindowDestroying(
     aura::Window* window) {
   StopObserving(window);
 }
 
-ImmersiveFocusWatcherClassic::ImmersiveFocusWatcherClassic(
+ImmersiveFocusWatcher::ImmersiveFocusWatcher(
     ImmersiveFullscreenController* controller)
     : immersive_fullscreen_controller_(controller) {
   GetWidget()->GetFocusManager()->AddFocusChangeListener(this);
-  GetWidget()->AddObserver(this);
-  ::wm::TransientWindowManager::GetOrCreate(GetWidgetWindow())
+  aura::client::GetTransientWindowClient()->AddObserver(this);
+  ::wm::GetActivationClient(GetWidgetWindow()->GetRootWindow())
       ->AddObserver(this);
   RecreateBubbleObserver();
 }
 
-ImmersiveFocusWatcherClassic::~ImmersiveFocusWatcherClassic() {
-  ::wm::TransientWindowManager::GetOrCreate(GetWidgetWindow())
-      ->RemoveObserver(this);
+ImmersiveFocusWatcher::~ImmersiveFocusWatcher() {
+  aura::client::GetTransientWindowClient()->RemoveObserver(this);
   GetWidget()->GetFocusManager()->RemoveFocusChangeListener(this);
-  GetWidget()->RemoveObserver(this);
+  auto* activation_client =
+      ::wm::GetActivationClient(GetWidgetWindow()->GetRootWindow());
+  if (activation_client)
+    activation_client->RemoveObserver(this);
 }
 
-void ImmersiveFocusWatcherClassic::UpdateFocusRevealedLock() {
+void ImmersiveFocusWatcher::UpdateFocusRevealedLock() {
   views::Widget* widget = GetWidget();
   views::View* top_container =
       immersive_fullscreen_controller_->top_container();
@@ -185,7 +188,7 @@ void ImmersiveFocusWatcherClassic::UpdateFocusRevealedLock() {
     if (top_container->Contains(focused_view))
       hold_lock = true;
   } else {
-    aura::Window* native_window = widget->GetNativeWindow();
+    aura::Window* native_window = GetWidgetWindow();
     aura::Window* active_window =
         ::wm::GetActivationClient(native_window->GetRootWindow())
             ->GetActiveWindow();
@@ -223,22 +226,23 @@ void ImmersiveFocusWatcherClassic::UpdateFocusRevealedLock() {
   }
 }
 
-void ImmersiveFocusWatcherClassic::ReleaseLock() {
+void ImmersiveFocusWatcher::ReleaseLock() {
   lock_.reset();
 }
 
-views::Widget* ImmersiveFocusWatcherClassic::GetWidget() {
+views::Widget* ImmersiveFocusWatcher::GetWidget() {
   return immersive_fullscreen_controller_->widget();
 }
 
-aura::Window* ImmersiveFocusWatcherClassic::GetWidgetWindow() {
+aura::Window* ImmersiveFocusWatcher::GetWidgetWindow() {
   return GetWidget()->GetNativeWindow();
 }
 
-void ImmersiveFocusWatcherClassic::RecreateBubbleObserver() {
+void ImmersiveFocusWatcher::RecreateBubbleObserver() {
   bubble_observer_.reset(new BubbleObserver(immersive_fullscreen_controller_));
   const std::vector<aura::Window*> transient_children =
-      ::wm::GetTransientChildren(GetWidgetWindow());
+      aura::client::GetTransientWindowClient()->GetTransientChildren(
+          GetWidgetWindow());
   for (size_t i = 0; i < transient_children.size(); ++i) {
     aura::Window* transient_child = transient_children[i];
     views::View* anchor_view = GetAnchorView(transient_child);
@@ -249,22 +253,22 @@ void ImmersiveFocusWatcherClassic::RecreateBubbleObserver() {
   }
 }
 
-void ImmersiveFocusWatcherClassic::OnWillChangeFocus(
-    views::View* focused_before,
-    views::View* focused_now) {}
+void ImmersiveFocusWatcher::OnWillChangeFocus(views::View* focused_before,
+                                              views::View* focused_now) {}
 
-void ImmersiveFocusWatcherClassic::OnDidChangeFocus(views::View* focused_before,
-                                                    views::View* focused_now) {
+void ImmersiveFocusWatcher::OnDidChangeFocus(views::View* focused_before,
+                                             views::View* focused_now) {
   UpdateFocusRevealedLock();
 }
 
-void ImmersiveFocusWatcherClassic::OnWidgetActivationChanged(
-    views::Widget* widget,
-    bool active) {
+void ImmersiveFocusWatcher::OnWindowActivated(
+    ::wm::ActivationChangeObserver::ActivationReason reason,
+    aura::Window* gaining_active,
+    aura::Window* losing_active) {
   UpdateFocusRevealedLock();
 }
 
-void ImmersiveFocusWatcherClassic::OnTransientChildAdded(
+void ImmersiveFocusWatcher::OnTransientChildWindowAdded(
     aura::Window* window,
     aura::Window* transient) {
   views::View* anchor = GetAnchorView(transient);
@@ -277,7 +281,7 @@ void ImmersiveFocusWatcherClassic::OnTransientChildAdded(
   }
 }
 
-void ImmersiveFocusWatcherClassic::OnTransientChildRemoved(
+void ImmersiveFocusWatcher::OnTransientChildWindowRemoved(
     aura::Window* window,
     aura::Window* transient) {
   bubble_observer_->StopObserving(transient);

ash/public/cpp/immersive/immersive_focus_watcher.h

-// Copyright 2016 The Chromium Authors. All rights reserved.
+// Copyright 2018 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 ASH_PUBLIC_CPP_IMMERSIVE_IMMERSIVE_FOCUS_WATCHER_H_
 #define ASH_PUBLIC_CPP_IMMERSIVE_IMMERSIVE_FOCUS_WATCHER_H_
 
-#include "ash/public/cpp/ash_public_export.h"
+#include "ui/aura/client/focus_change_observer.h"
+#include "ui/aura/client/transient_window_client_observer.h"
+#include "ui/views/focus/focus_manager.h"
+#include "ui/wm/public/activation_change_observer.h"
 
 namespace ash {
+class ImmersiveFullscreenController;
+class ImmersiveRevealedLock;
 
 // ImmersiveFocusWatcher is responsible for grabbing a reveal lock based on
-// activation and/or focus.
-class ASH_PUBLIC_EXPORT ImmersiveFocusWatcher {
+// activation and/or focus. This implementation grabs a lock if views focus is
+// in the top view, a bubble is showing that is anchored to the top view, or
+// the focused window is a transient child of the top view's widget.
+class ImmersiveFocusWatcher
+    : public views::FocusChangeListener,
+      public aura::client::TransientWindowClientObserver,
+      public ::wm::ActivationChangeObserver {
  public:
-  virtual ~ImmersiveFocusWatcher() {}
+  explicit ImmersiveFocusWatcher(ImmersiveFullscreenController* controller);
+  ~ImmersiveFocusWatcher() override;
 
   // Forces updating the status of the lock. That is, this determines whether
   // a lock should be held and updates accordingly. The lock is automatically
   // maintained, but this function may be called to force an update.
-  virtual void UpdateFocusRevealedLock() = 0;
+  void UpdateFocusRevealedLock();
 
   // Explicitly releases the lock, does nothing if a lock is not held.
-  virtual void ReleaseLock() = 0;
+  void ReleaseLock();
+
+ private:
+  class BubbleObserver;
+
+  views::Widget* GetWidget();
+  aura::Window* GetWidgetWindow();
+
+  // Recreate |bubble_observer_| and start observing any bubbles anchored to a
+  // child of |top_container_|.
+  void RecreateBubbleObserver();
+
+  // views::FocusChangeListener overrides:
+  void OnWillChangeFocus(views::View* focused_before,
+                         views::View* focused_now) override;
+  void OnDidChangeFocus(views::View* focused_before,
+                        views::View* focused_now) override;
+
+  // aura::client::TransientWindowClientObserver overrides:
+  void OnTransientChildWindowAdded(aura::Window* window,
+                                   aura::Window* transient) override;
+  void OnTransientChildWindowRemoved(aura::Window* window,
+                                     aura::Window* transient) override;
+
+  // ::wm::ActivationChangeObserver:
+  void OnWindowActivated(
+      ::wm::ActivationChangeObserver::ActivationReason reason,
+      aura::Window* gaining_active,
+      aura::Window* losing_active) override;
+
+  ImmersiveFullscreenController* immersive_fullscreen_controller_;
+
+  // Lock which keeps the top-of-window views revealed based on the focused view
+  // and the active widget. Acquiring the lock never triggers a reveal because
+  // a view is not focusable till a reveal has made it visible.
+  std::unique_ptr<ImmersiveRevealedLock> lock_;
+
+  // Manages bubbles which are anchored to a child of
+  // |ImmersiveFullscreenController::top_container_|.
+  std::unique_ptr<BubbleObserver> bubble_observer_;
+
+  DISALLOW_COPY_AND_ASSIGN(ImmersiveFocusWatcher);
 };
 
 }  // namespace ash

ash/public/cpp/immersive/immersive_fullscreen_controller.cc

@@ -327,8 +327,7 @@ void ImmersiveFullscreenController::EnableEventObservers(bool enable) {
 
   aura::Env* env = widget_->GetNativeWindow()->env();
   if (enable) {
-    immersive_focus_watcher_ =
-        ImmersiveHandlerFactory::Get()->CreateFocusWatcher(this);
+    immersive_focus_watcher_ = std::make_unique<ImmersiveFocusWatcher>(this);
     immersive_gesture_handler_ =
         ImmersiveHandlerFactory::Get()->CreateGestureHandler(this);
     std::set<ui::EventType> types = {

ash/public/cpp/immersive/immersive_handler_factory.h

@@ -11,7 +11,6 @@
 
 namespace ash {
 
-class ImmersiveFocusWatcher;
 class ImmersiveFullscreenController;
 class ImmersiveGestureHandler;
 
@@ -20,9 +19,6 @@ class ASH_PUBLIC_EXPORT ImmersiveHandlerFactory {
  public:
   static ImmersiveHandlerFactory* Get() { return instance_; }
 
-  virtual std::unique_ptr<ImmersiveFocusWatcher> CreateFocusWatcher(
-      ImmersiveFullscreenController* controller) = 0;
-
   virtual std::unique_ptr<ImmersiveGestureHandler> CreateGestureHandler(
       ImmersiveFullscreenController* controller) = 0;
 

ash/wm/immersive_focus_watcher_classic.h

-// Copyright 2016 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 ASH_WM_IMMERSIVE_FOCUS_WATCHER_CLASSIC_H_
-#define ASH_WM_IMMERSIVE_FOCUS_WATCHER_CLASSIC_H_
-
-#include "ash/ash_export.h"
-#include "ash/public/cpp/immersive/immersive_focus_watcher.h"
-#include "ui/views/focus/focus_manager.h"
-#include "ui/views/widget/widget_observer.h"
-#include "ui/wm/core/transient_window_observer.h"
-
-namespace ash {
-
-class ImmersiveFullscreenController;
-class ImmersiveRevealedLock;
-
-// ImmersiveFocusWatcher is responsible for grabbing a reveal lock based on
-// activation and/or focus. This implementation grabs a lock if views focus is
-// in the top view, or a bubble is showing that is anchored to the top view.
-class ASH_EXPORT ImmersiveFocusWatcherClassic
-    : public ImmersiveFocusWatcher,
-      public views::FocusChangeListener,
-      public views::WidgetObserver,
-      public ::wm::TransientWindowObserver {
- public:
-  explicit ImmersiveFocusWatcherClassic(
-      ImmersiveFullscreenController* controller);
-  ~ImmersiveFocusWatcherClassic() override;
-
-  // ImmersiveFocusWatcher:
-  void UpdateFocusRevealedLock() override;
-  void ReleaseLock() override;
-
- private:
-  class BubbleObserver;
-
-  views::Widget* GetWidget();
-  aura::Window* GetWidgetWindow();
-
-  // Recreate |bubble_observer_| and start observing any bubbles anchored to a
-  // child of |top_container_|.
-  void RecreateBubbleObserver();
-
-  // views::FocusChangeObserver overrides:
-  void OnWillChangeFocus(views::View* focused_before,
-                         views::View* focused_now) override;
-  void OnDidChangeFocus(views::View* focused_before,
-                        views::View* focused_now) override;
-
-  // views::WidgetObserver overrides:
-  void OnWidgetActivationChanged(views::Widget* widget, bool active) override;
-
-  // ::wm::TransientWindowObserver overrides:
-  void OnTransientChildAdded(aura::Window* window,
-                             aura::Window* transient) override;
-  void OnTransientChildRemoved(aura::Window* window,
-                               aura::Window* transient) override;
-
-  ImmersiveFullscreenController* immersive_fullscreen_controller_;
-
-  // Lock which keeps the top-of-window views revealed based on the focused view
-  // and the active widget. Acquiring the lock never triggers a reveal because
-  // a view is not focusable till a reveal has made it visible.
-  std::unique_ptr<ImmersiveRevealedLock> lock_;
-
-  // Manages bubbles which are anchored to a child of
-  // |ImmersiveFullscreenController::top_container_|.
-  std::unique_ptr<BubbleObserver> bubble_observer_;
-
-  DISALLOW_COPY_AND_ASSIGN(ImmersiveFocusWatcherClassic);
-};
-
-}  // namespace ash
-
-#endif  // ASH_WM_IMMERSIVE_FOCUS_WATCHER_CLASSIC_H_

ash/wm/immersive_handler_factory_ash.cc

@@ -6,7 +6,6 @@
 
 #include <memory>
 
-#include "ash/wm/immersive_focus_watcher_classic.h"
 #include "ash/wm/immersive_gesture_handler_classic.h"
 
 namespace ash {
@@ -15,12 +14,6 @@ ImmersiveHandlerFactoryAsh::ImmersiveHandlerFactoryAsh() = default;
 
 ImmersiveHandlerFactoryAsh::~ImmersiveHandlerFactoryAsh() = default;
 
-std::unique_ptr<ImmersiveFocusWatcher>
-ImmersiveHandlerFactoryAsh::CreateFocusWatcher(
-    ImmersiveFullscreenController* controller) {
-  return std::make_unique<ImmersiveFocusWatcherClassic>(controller);
-}
-
 std::unique_ptr<ImmersiveGestureHandler>
 ImmersiveHandlerFactoryAsh::CreateGestureHandler(
     ImmersiveFullscreenController* controller) {

ash/wm/immersive_handler_factory_ash.h

@@ -17,8 +17,6 @@ class ASH_EXPORT ImmersiveHandlerFactoryAsh : public ImmersiveHandlerFactory {
   ~ImmersiveHandlerFactoryAsh() override;
 
   // ImmersiveHandlerFactory:
-  std::unique_ptr<ImmersiveFocusWatcher> CreateFocusWatcher(
-      ImmersiveFullscreenController* controller) override;
   std::unique_ptr<ImmersiveGestureHandler> CreateGestureHandler(
       ImmersiveFullscreenController* controller) override;
 

chrome/browser/ui/BUILD.gn

@@ -1444,8 +1444,6 @@ jumbo_split_static_library("ui") {
       "views/frame/browser_non_client_frame_view_ash.h",
       "views/frame/immersive_context_mus.cc",
       "views/frame/immersive_context_mus.h",
-      "views/frame/immersive_focus_watcher_mus.cc",
-      "views/frame/immersive_focus_watcher_mus.h",
       "views/frame/immersive_handler_factory_mus.cc",
       "views/frame/immersive_handler_factory_mus.h",
       "views/frame/immersive_mode_controller_ash.cc",

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

-// Copyright 2018 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_VIEWS_FRAME_IMMERSIVE_FOCUS_WATCHER_MUS_H_
-#define CHROME_BROWSER_UI_VIEWS_FRAME_IMMERSIVE_FOCUS_WATCHER_MUS_H_
-
-#include "ash/public/cpp/immersive/immersive_focus_watcher.h"
-#include "ui/aura/client/focus_change_observer.h"
-#include "ui/aura/client/transient_window_client_observer.h"
-#include "ui/views/focus/focus_manager.h"
-#include "ui/wm/public/activation_change_observer.h"
-
-namespace ash {
-class ImmersiveFullscreenController;
-class ImmersiveRevealedLock;
-}  // namespace ash
-
-// ImmersiveFocusWatcherMus is responsible for grabbing a reveal lock based on
-// activation and/or focus. This implementation grabs a lock if views focus is
-// in the top view, a bubble is showing that is anchored to the top view, or
-// the focused window is a transient child of the top view's widget.
-class ImmersiveFocusWatcherMus
-    : public ash::ImmersiveFocusWatcher,
-      public views::FocusChangeListener,
-      public aura::client::TransientWindowClientObserver,
-      public ::wm::ActivationChangeObserver {
- public:
-  explicit ImmersiveFocusWatcherMus(
-      ash::ImmersiveFullscreenController* controller);
-  ~ImmersiveFocusWatcherMus() override;
-
-  // ImmersiveFocusWatcher:
-  void UpdateFocusRevealedLock() override;
-  void ReleaseLock() override;
-
- private:
-  class BubbleObserver;
-
-  views::Widget* GetWidget();
-  aura::Window* GetWidgetWindow();
-
-  // Recreate |bubble_observer_| and start observing any bubbles anchored to a
-  // child of |top_container_|.
-  void RecreateBubbleObserver();
-
-  // views::FocusChangeListener overrides:
-  void OnWillChangeFocus(views::View* focused_before,
-                         views::View* focused_now) override;
-  void OnDidChangeFocus(views::View* focused_before,
-                        views::View* focused_now) override;
-
-  // aura::client::TransientWindowClientObserver overrides:
-  void OnTransientChildWindowAdded(aura::Window* window,
-                                   aura::Window* transient) override;
-  void OnTransientChildWindowRemoved(aura::Window* window,
-                                     aura::Window* transient) override;
-
-  // ::wm::ActivationChangeObserver:
-  void OnWindowActivated(
-      ::wm::ActivationChangeObserver::ActivationReason reason,
-      aura::Window* gaining_active,
-      aura::Window* losing_active) override;
-
-  ash::ImmersiveFullscreenController* immersive_fullscreen_controller_;
-
-  // Lock which keeps the top-of-window views revealed based on the focused view
-  // and the active widget. Acquiring the lock never triggers a reveal because
-  // a view is not focusable till a reveal has made it visible.
-  std::unique_ptr<ash::ImmersiveRevealedLock> lock_;
-
-  // Manages bubbles which are anchored to a child of
-  // |ImmersiveFullscreenController::top_container_|.
-  std::unique_ptr<BubbleObserver> bubble_observer_;
-
-  DISALLOW_COPY_AND_ASSIGN(ImmersiveFocusWatcherMus);
-};
-
-#endif  // CHROME_BROWSER_UI_VIEWS_FRAME_IMMERSIVE_FOCUS_WATCHER_MUS_H_

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

@@ -4,21 +4,13 @@
 
 #include "chrome/browser/ui/views/frame/immersive_handler_factory_mus.h"
 
-#include "ash/public/cpp/immersive/immersive_focus_watcher.h"
 #include "ash/public/cpp/immersive/immersive_gesture_handler.h"
 #include "base/logging.h"
-#include "chrome/browser/ui/views/frame/immersive_focus_watcher_mus.h"
 
 ImmersiveHandlerFactoryMus::ImmersiveHandlerFactoryMus() {}
 
 ImmersiveHandlerFactoryMus::~ImmersiveHandlerFactoryMus() {}
 
-std::unique_ptr<ash::ImmersiveFocusWatcher>
-ImmersiveHandlerFactoryMus::CreateFocusWatcher(
-    ash::ImmersiveFullscreenController* controller) {
-  return std::make_unique<ImmersiveFocusWatcherMus>(controller);
-}
-
 std::unique_ptr<ash::ImmersiveGestureHandler>
 ImmersiveHandlerFactoryMus::CreateGestureHandler(
     ash::ImmersiveFullscreenController* controller) {

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

@@ -14,8 +14,6 @@ class ImmersiveHandlerFactoryMus : public ash::ImmersiveHandlerFactory {
   ~ImmersiveHandlerFactoryMus() override;
 
   // ImmersiveHandlerFactory:
-  std::unique_ptr<ash::ImmersiveFocusWatcher> CreateFocusWatcher(
-      ash::ImmersiveFullscreenController* controller) override;
   std::unique_ptr<ash::ImmersiveGestureHandler> CreateGestureHandler(
       ash::ImmersiveFullscreenController* controller) override;
 

testing/buildbot/filters/chromeos.single_process_mash.browser_tests.filter

@@ -224,9 +224,6 @@
 -WindowOpenApiTest.UpdateWindowToLockedFullscreen
 -WindowOpenApiTest.VerifyCommandsInLockedFullscreen
 
-# Value of: immersive_controller->IsRevealed()
--ZoomBubbleBrowserTest.ImmersiveFullscreen
-
 # Flaky tests. crbug.com/833144
 -GetAuthTokenFunctionPublicSessionTest.NonWhitelisted