views/mus: Chaneg how Widget activation works in mus.

ui/views/mus/native_widget_mus.cc

 // Copyright 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 "ui/views/mus/native_widget_mus.h"
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 55 matching lines @@
   bool SupportsChildActivation(aura::Window* window) const override {
     return root_ == window;
   }
 
  private:
   aura::Window* root_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusRulesImpl);
 };
 
+// This makes sure that an aura::Window focused (or activated) through the
+// aura::client::FocusClient (or ActivationClient) focuses (or activates) the
+// corresponding mus::Window too.
+class FocusControllerMus : public wm::FocusController {
+ public:
+  explicit FocusControllerMus(wm::FocusRules* rules) : FocusController(rules) {}
+  ~FocusControllerMus() override {}
+
+ private:
+  void FocusWindow(aura::Window* window) override {
+    FocusController::FocusWindow(window);
+    if (window) {
+      mus::Window* mus_window =
+          window->GetRootWindow()->GetProperty(kMusWindow);
+      if (mus_window)
+        mus_window->SetFocus();
+    }
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(FocusControllerMus);
+};
+
 class ContentWindowLayoutManager : public aura::LayoutManager {
  public:
    ContentWindowLayoutManager(aura::Window* outer, aura::Window* inner)
       : outer_(outer), inner_(inner) {}
    ~ContentWindowLayoutManager() override {}
 
  private:
   // aura::LayoutManager:
   void OnWindowResized() override { inner_->SetBounds(outer_->bounds()); }
   void OnWindowAddedToLayout(aura::Window* child) override {
@@ skipping 570 matching lines @@
 
   ownership_ = params.ownership;
   window_->SetCanFocus(params.activatable ==
                        Widget::InitParams::ACTIVATABLE_YES);
 
   window_tree_host_->AddObserver(this);
   window_tree_host_->InitHost();
   hosted_window->SetProperty(kMusWindow, window_);
 
   focus_client_.reset(
-      new wm::FocusController(new FocusRulesImpl(hosted_window)));
+      new FocusControllerMus(new FocusRulesImpl(hosted_window)));
 
   aura::client::SetFocusClient(hosted_window, focus_client_.get());
   aura::client::SetActivationClient(hosted_window, focus_client_.get());
   screen_position_client_.reset(new ScreenPositionClientMus(window_));
   aura::client::SetScreenPositionClient(hosted_window,
                                         screen_position_client_.get());
 
   // TODO(erg): Remove this check when ash/mus/frame/move_event_handler.cc's
   // direct usage of mus::Window::SetPredefinedCursor() is switched to a
   // private method on WindowManagerClient.
@@ skipping 297 matching lines @@
     GetWidget()->SetInitialFocus(state);
   }
 }
 
 bool NativeWidgetMus::IsVisible() const {
   // TODO(beng): this should probably be wired thru PlatformWindow.
   return window_ && window_->visible();
 }
 
 void NativeWidgetMus::Activate() {
-  if (window_)
-    window_->SetFocus();
   static_cast<aura::client::ActivationClient*>(focus_client_.get())
       ->ActivateWindow(content_);
+  // FocusControllerMus should have focused |window_| when |content_| is
+  // activated.
+  DCHECK(!window_ || window_->HasFocus());
 }
 
 void NativeWidgetMus::Deactivate() {
   if (IsActive())
     window_->window_tree()->ClearFocus();
 }
 
 bool NativeWidgetMus::IsActive() const {
   mus::Window* focused =
       window_ ? window_->window_tree()->GetFocusedWindow() : nullptr;
@@ skipping 371 matching lines @@
 
   gfx::Path mask_path;
   native_widget_delegate_->GetHitTestMask(&mask_path);
   // TODO(jamescook): Use the full path for the mask.
   gfx::Rect mask_rect =
       gfx::ToEnclosingRect(gfx::SkRectToRectF(mask_path.getBounds()));
   window_->SetHitTestMask(mask_rect);
 }
 
 }  // namespace views