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"
@@ skipping 13 matching lines @@
 namespace {
 
 // Returns a small colored bitmap.
 SkBitmap MakeBitmap(SkColor color) {
   SkBitmap bitmap;
   bitmap.allocN32Pixels(8, 8);
   bitmap.eraseColor(color);
   return bitmap;
 }
 
+// A Widget that tracks activation changes.

[sky, 2016/04/07 17:55:10]

Rather than creating a widget subclass can you use WidgetFocusChangeListener and
WidgetObserver?

It looks like widget_interactive_uitests provides coverage of what you're after
here. Can we run that test in views_mus_unittests?

[James Cook, 2016/04/07 20:43:43]

Switched to using TestWidgetFocusChangeListener and a WidgetObserver.

I poked at running widget_interactive_uitests in views_mus_unittests but didn't
have much luck. :-(

+class TestWidget : public Widget {
+ public:
+  TestWidget() {}
+  ~TestWidget() override {}
+
+  bool last_activation_change() const { return last_activation_change_; }
+  int focus_count() const { return focus_count_; }
+  int blur_count() const { return blur_count_; }
+
+  void ResetCounts() {
+    focus_count_ = 0;
+    blur_count_ = 0;
+  }
+
+  // views::internal::NativeWidgetDelegate:
+  void OnNativeWidgetActivationChanged(bool active) override {
+    last_activation_change_ = active;
+    Widget::OnNativeWidgetActivationChanged(active);
+  }
+  void OnNativeFocus() override {
+    focus_count_++;
+    Widget::OnNativeFocus();
+  }
+  void OnNativeBlur() override {
+    blur_count_++;
+    Widget::OnNativeBlur();
+  }
+
+ private:
+  bool last_activation_change_ = false;
+  int focus_count_ = 0;
+  int blur_count_ = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(TestWidget);
+};
+
 // 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();
+  TestWidget* CreateWidget(TestWidgetDelegate* delegate) {

[sky, 2016/04/07 17:55:10]

Make this return a scoped_ptr

[James Cook, 2016/04/07 20:43:43]

Done.

+    TestWidget* widget = new TestWidget();
     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 that native window activation and focus is passed to the Widget.
+TEST_F(NativeWidgetMusTest, OnActivationChanged) {
+  scoped_ptr<TestWidget> widget(CreateWidget(nullptr));
+  NativeWidgetMus* native_widget = static_cast<NativeWidgetMus*>(widget
+      ->native_widget_private());
+
+  // Simulate native widget being activated.
+  native_widget->OnActivationChanged(true);

[sky, 2016/04/07 17:55:10]

If you call widget->Activate() does it call this?

[James Cook, 2016/04/07 20:43:43]

Yes. Changed test to start the widget in the shown/active state, then use
widget->Deactivate() and Activate().

+  EXPECT_EQ(1, widget->focus_count());
+  EXPECT_EQ(0, widget->blur_count());
+  EXPECT_TRUE(widget->last_activation_change());
+
+  widget->ResetCounts();
+
+  // Simulate native widget being deactivated.
+  native_widget->OnActivationChanged(false);
+  EXPECT_EQ(0, widget->focus_count());
+  EXPECT_EQ(1, widget->blur_count());
+  EXPECT_FALSE(widget->last_activation_change());
+}
+
 // 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