mash: Make system tray bubble close when another window is activated

ui/views/mus/native_widget_mus_unittest.cc

 // 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.
 
 #include "ui/views/mus/native_widget_mus.h"
 
 #include "base/macros.h"
 #include "components/mus/public/cpp/property_type_converters.h"
 #include "components/mus/public/cpp/window.h"
 #include "components/mus/public/cpp/window_property.h"
 #include "components/mus/public/interfaces/window_manager.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/aura/window.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/skia_util.h"
+#include "ui/views/test/focus_manager_test.h"
 #include "ui/views/test/views_test_base.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
+#include "ui/views/widget/widget_observer.h"
 
 namespace views {
 namespace {
 
 // Returns a small colored bitmap.
 SkBitmap MakeBitmap(SkColor color) {
   SkBitmap bitmap;
   bitmap.allocN32Pixels(8, 8);
   bitmap.eraseColor(color);
   return bitmap;
 }
 
+// An observer that tracks widget activation changes.
+class WidgetActivationObserver : public WidgetObserver {
+ public:
+  explicit WidgetActivationObserver(Widget* widget) : widget_(widget) {
+    widget_->AddObserver(this);
+  }
+
+  ~WidgetActivationObserver() override {
+    widget_->RemoveObserver(this);
+  }
+
+  const std::vector<bool>& changes() const { return changes_; }
+
+  // WidgetObserver:
+  void OnWidgetActivationChanged(Widget* widget, bool active) override {
+    ASSERT_EQ(widget_, widget);
+    changes_.push_back(active);
+  }
+
+ private:
+  Widget* widget_;
+  std::vector<bool> changes_;
+
+  DISALLOW_COPY_AND_ASSIGN(WidgetActivationObserver);
+};
+
 // A WidgetDelegate that supplies an app icon.
 class TestWidgetDelegate : public WidgetDelegateView {
  public:
   explicit TestWidgetDelegate(const SkBitmap& icon)
       : app_icon_(gfx::ImageSkia::CreateFrom1xBitmap(icon)) {}
 
   ~TestWidgetDelegate() override {}
 
   void SetIcon(const SkBitmap& icon) {
     app_icon_ = gfx::ImageSkia::CreateFrom1xBitmap(icon);
   }
 
   // views::WidgetDelegate:
   gfx::ImageSkia GetWindowAppIcon() override { return app_icon_; }
 
  private:
   gfx::ImageSkia app_icon_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWidgetDelegate);
 };
 
 class NativeWidgetMusTest : public ViewsTestBase {
  public:
   NativeWidgetMusTest() {}
   ~NativeWidgetMusTest() override {}
 
   // Creates a test widget. Takes ownership of |delegate|.
-  Widget* CreateWidget(TestWidgetDelegate* delegate) {
-    Widget* widget = new Widget();
+  scoped_ptr<Widget> CreateWidget(TestWidgetDelegate* delegate) {
+    scoped_ptr<Widget> widget(new Widget());
     Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_WINDOW);
     params.delegate = delegate;
     params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
     params.bounds = gfx::Rect(10, 20, 100, 200);
     widget->Init(params);
     return widget;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NativeWidgetMusTest);
 };
 
+// Tests communication of activation and focus between Widget and
+// NativeWidgetMus.
+TEST_F(NativeWidgetMusTest, OnActivationChanged) {
+  scoped_ptr<Widget> widget(CreateWidget(nullptr));
+  widget->Show();
+
+  // Track activation, focus and blur events.
+  WidgetActivationObserver activation_observer(widget.get());
+  TestWidgetFocusChangeListener focus_listener;
+  WidgetFocusManager::GetInstance()->AddFocusChangeListener(&focus_listener);
+
+  // Deactivate the Widget, which deactivates the NativeWidgetMus.
+  widget->Deactivate();
+
+  // The widget is blurred and deactivated.
+  ASSERT_EQ(1u, focus_listener.focus_changes().size());
+  EXPECT_EQ(nullptr, focus_listener.focus_changes()[0]);
+  ASSERT_EQ(1u, activation_observer.changes().size());
+  EXPECT_EQ(false, activation_observer.changes()[0]);
+
+  // Re-activate the Widget, which actives the NativeWidgetMus.
+  widget->Activate();
+
+  // The widget is focused and activated.
+  ASSERT_EQ(2u, focus_listener.focus_changes().size());
+  EXPECT_EQ(widget->GetNativeView(), focus_listener.focus_changes()[1]);
+  ASSERT_EQ(2u, activation_observer.changes().size());
+  EXPECT_TRUE(activation_observer.changes()[1]);
+
+  WidgetFocusManager::GetInstance()->RemoveFocusChangeListener(&focus_listener);
+}
+
 // Tests that a window with an icon sets the mus::Window icon property.
 TEST_F(NativeWidgetMusTest, AppIcon) {
   // Create a Widget with a bitmap as the icon.
   SkBitmap source_bitmap = MakeBitmap(SK_ColorRED);
   scoped_ptr<Widget> widget(
       CreateWidget(new TestWidgetDelegate(source_bitmap)));
 
   // The mus::Window has the icon property.
   mus::Window* window =
       static_cast<NativeWidgetMus*>(widget->native_widget_private())->window();
@@ skipping 43 matching lines @@
 TEST_F(NativeWidgetMusTest, ValidLayerTree) {
   scoped_ptr<Widget> widget(CreateWidget(nullptr));
   View* content = new View;
   content->SetPaintToLayer(true);
   widget->GetContentsView()->AddChildView(content);
   EXPECT_TRUE(widget->GetNativeWindow()->layer()->Contains(content->layer()));
 }
 
 }  // namespace
 }  // namespace views