Adds capture to the mojo window_manager.

services/window_manager/focus_controller_unittest.cc

 // Copyright (c) 2012 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 "services/window_manager/focus_controller.h"
 
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "services/window_manager/basic_focus_rules.h"
+#include "services/window_manager/capture_controller.h"
 #include "services/window_manager/focus_controller_observer.h"
 #include "services/window_manager/view_event_dispatcher.h"
 #include "services/window_manager/view_targeter.h"
 #include "services/window_manager/window_manager_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/geometry/rect.h"
 
 using mojo::View;
 
@@ skipping 321 matching lines @@
         v211(TestView::Build(211, gfx::Rect(1, 1, 5, 5), v21)),
         v3(TestView::Build(3, gfx::Rect(125, 125, 50, 50), root_view())) {}
 
   // Overridden from testing::Test:
   void SetUp() override {
     testing::Test::SetUp();
 
     test_focus_rules_ = new TestFocusRules(root_view());
     focus_controller_.reset(
         new FocusController(scoped_ptr<FocusRules>(test_focus_rules_)));
+    SetFocusController(root_view(), focus_controller_.get());
+
+    capture_controller_.reset(new CaptureController);
+    SetCaptureController(root_view(), capture_controller_.get());
 
     ViewTarget* root_target = root_view_->target();
     root_target->SetEventTargeter(scoped_ptr<ViewTargeter>(new ViewTargeter()));
     view_event_dispatcher_.reset(new ViewEventDispatcher());
     view_event_dispatcher_->SetRootViewTarget(root_target);
 
     GetRootViewTarget()->AddPreTargetHandler(focus_controller_.get());
   }
 
   void TearDown() override {
     GetRootViewTarget()->RemovePreTargetHandler(focus_controller_.get());
     view_event_dispatcher_.reset();
 
     root_view_->Destroy();
 
+    capture_controller_.reset();
     test_focus_rules_ = nullptr;  // Owned by FocusController.
     focus_controller_.reset();
 
     testing::Test::TearDown();
   }
 
   void FocusView(View* view) { focus_controller_->FocusView(view); }
   View* GetFocusedView() { return focus_controller_->GetFocusedView(); }
   int GetFocusedViewId() {
     View* focused_view = GetFocusedView();
@@ skipping 28 matching lines @@
     CHECK(!details.dispatcher_destroyed);
   }
 
   ViewTarget* GetRootViewTarget() {
     return ViewTarget::TargetFromView(root_view());
   }
 
   View* root_view() { return root_view_; }
   TestFocusRules* test_focus_rules() { return test_focus_rules_; }
   FocusController* focus_controller() { return focus_controller_.get(); }
+  CaptureController* capture_controller() { return capture_controller_.get(); }
 
   // Test functions.
   virtual void BasicFocus() = 0;
   virtual void BasicActivation() = 0;
   virtual void FocusEvents() = 0;
   virtual void DuplicateFocusEvents() {}
   virtual void ActivationEvents() = 0;
   virtual void ReactivationEvents() {}
   virtual void DuplicateActivationEvents() {}
   virtual void ShiftFocusWithinActiveView() {}
   virtual void ShiftFocusToChildOfInactiveView() {}
   virtual void ShiftFocusToParentOfFocusedView() {}
   virtual void FocusRulesOverride() = 0;
   virtual void ActivationRulesOverride() = 0;
   virtual void ShiftFocusOnActivation() {}
   virtual void ShiftFocusOnActivationDueToHide() {}
   virtual void NoShiftActiveOnActivation() {}
-  // TODO(erg): void NoFocusChangeOnClickOnCaptureWindow() once we have a
-  // system of capture.
-  // TODO(erg): Also, void ChangeFocusWhenNothingFocusedAndCaptured().
+  virtual void NoFocusChangeOnClickOnCaptureWindow() {}
+  virtual void ChangeFocusWhenNothingFocusedAndCaptured() {}
   virtual void DontPassDestroyedView() {}
   // TODO(erg): Also, void FocusedTextInputClient() once we build the IME.
 
  private:
   TestView* root_view_;
   scoped_ptr<FocusController> focus_controller_;
   TestFocusRules* test_focus_rules_;
+  scoped_ptr<CaptureController> capture_controller_;
   // TODO(erg): The aura version of this class also keeps track of WMState. Do
   // we need something analogous here?
 
   scoped_ptr<ViewEventDispatcher> view_event_dispatcher_;
 
   TestView* v1;
   TestView* v11;
   TestView* v12;
   TestView* v2;
   TestView* v21;
@@ skipping 266 matching lines @@
 
     EXPECT_EQ(21, GetFocusedViewId());
 
     focus_controller()->RemoveObserver(observer.get());
   }
   void NoShiftActiveOnActivation() override {
     // When a view is activated, we need to prevent any change to activation
     // from being made in response to an activation change notification.
   }
 
-  // TODO(erg): Port the capture tests here, once we have a capture mechanism.
+  void NoFocusChangeOnClickOnCaptureWindow() override {
+    // Clicking on a view which has capture should not cause a focus change
+    // to the view. This test verifies whether that is indeed the case.
+    ActivateViewById(1);
+
+    EXPECT_EQ(1, GetActiveViewId());
+    EXPECT_EQ(1, GetFocusedViewId());
+
+    View* v2 = root_view()->GetChildById(2);
+    capture_controller()->SetCapture(v2);
+    ClickLeftButton(v2);
+
+    EXPECT_EQ(1, GetActiveViewId());
+    EXPECT_EQ(1, GetFocusedViewId());
+
+    capture_controller()->ReleaseCapture(v2);
+  }
+
+  // Verifies focus change is honored while capture held.
+  void ChangeFocusWhenNothingFocusedAndCaptured() override {
+    View* v1 = root_view()->GetChildById(1);
+    capture_controller()->SetCapture(v1);
+
+    EXPECT_EQ(-1, GetActiveViewId());
+    EXPECT_EQ(-1, GetFocusedViewId());
+
+    FocusViewById(1);
+
+    EXPECT_EQ(1, GetActiveViewId());
+    EXPECT_EQ(1, GetFocusedViewId());
+
+    capture_controller()->ReleaseCapture(v1);
+  }
 
   // Verifies if a view that loses activation or focus is destroyed during
   // observer notification we don't pass the destroyed view to other observers.
   void DontPassDestroyedView() override {
     FocusViewById(1);
 
     EXPECT_EQ(1, GetActiveViewId());
     EXPECT_EQ(1, GetFocusedViewId());
 
     {
@@ skipping 378 matching lines @@
 
 // - Verifies that FocusRules determine what can be activated.
 TARGET_FOCUS_TESTS(ActivationRulesOverride);
 
 // - Verifies that attempts to change focus or activation from a focus or
 //   activation change observer are ignored.
 DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusOnActivation);
 DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusOnActivationDueToHide);
 DIRECT_FOCUS_CHANGE_TESTS(NoShiftActiveOnActivation);
 
-// TODO(erg): Add the capture tests here.
+// Clicking on a window which has capture should not result in a focus change.
+DIRECT_FOCUS_CHANGE_TESTS(NoFocusChangeOnClickOnCaptureWindow);
+
+FOCUS_CONTROLLER_TEST(FocusControllerApiTest,
+                      ChangeFocusWhenNothingFocusedAndCaptured);
 
 // See description above DontPassDestroyedView() for details.
 FOCUS_CONTROLLER_TEST(FocusControllerApiTest, DontPassDestroyedView);
 
 // TODO(erg): Add the TextInputClient tests here.
 
 // If a mouse event was handled, it should not activate a view.
 FOCUS_CONTROLLER_TEST(FocusControllerMouseEventTest, IgnoreHandledEvent);
 
 }  // namespace window_manager