Make AppWindowWaiter a common test support

chrome/browser/extensions/api/tabs/tabs_test.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 <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 
+#include "apps/test/app_window_waiter.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/pattern.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/apps/app_browsertest_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/devtools/devtools_window_testing.h"
@@ skipping 16 matching lines @@
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/common/page_zoom.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/browser_test_utils.h"
 #include "extensions/browser/api_test_utils.h"
 #include "extensions/browser/app_window/app_window.h"
 #include "extensions/browser/app_window/app_window_registry.h"
-#include "extensions/browser/app_window/native_app_window.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/test_util.h"
 #include "extensions/test/extension_test_message_listener.h"
 #include "extensions/test/result_catcher.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "ui/base/window_open_disposition.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_observer.h"
 
@@ skipping 732 matching lines @@
 
   EXPECT_EQ(new_width, api_test_utils::GetInteger(result.get(), "width"));
   EXPECT_EQ(new_height, api_test_utils::GetInteger(result.get(), "height"));
 
   DevToolsWindowTesting::CloseDevToolsWindowSync(devtools);
 }
 
 // TODO(llandwerlin): Activating a browser window and waiting for the
 // action to happen requires views::Widget which is not available on
 // MacOSX. Deactivate for now.
+// TODO(warx): Move ExtensionWindowLastFocusedTest to interactive
+// uitest as it triggers native widget activation.
 #if !defined(OS_MACOSX)
 class ExtensionWindowLastFocusedTest : public ExtensionTabsTest {
  public:
   void SetUpOnMainThread() override;
 
-  void ActivateAppWindow(AppWindow* app_window);
-
   void ActivateBrowserWindow(Browser* browser);
 
   Browser* CreateBrowserWithEmptyTab(bool as_popup);
 
   int GetTabId(const base::DictionaryValue* value) const;
 
   base::Value* RunFunction(UIThreadExtensionFunction* function,
                            const std::string& params);
 
  private:
-  // A helper class to wait for an AppWindow to become activated. On
-  // window system like X11, for a NativeWidget to be activated, we
-  // need to wait for the round trip communication with the X server.
-  class AppWindowActivatedWaiter : public AppWindowRegistry::Observer {
-   public:
-    AppWindowActivatedWaiter(AppWindow* app_window,
-                             content::BrowserContext* browser_context)
-        : app_window_(app_window),
-          browser_context_(browser_context),
-          waiting_(false) {
-      AppWindowRegistry::Get(browser_context_)->AddObserver(this);
-    }
-    ~AppWindowActivatedWaiter() override {
-      AppWindowRegistry::Get(browser_context_)->RemoveObserver(this);
-    }
-
-    void ActivateAndWait() {
-      app_window_->GetBaseWindow()->Activate();
-      if (!app_window_->GetBaseWindow()->IsActive()) {
-        waiting_ = true;
-        content::RunMessageLoop();
-      }
-    }
-
-    // AppWindowRegistry::Observer:
-    void OnAppWindowActivated(AppWindow* app_window) override {
-      if (app_window_ == app_window && waiting_) {
-        base::MessageLoopForUI::current()->QuitWhenIdle();
-        waiting_ = false;
-      }
-    }
-
-   private:
-    AppWindow* app_window_;
-    content::BrowserContext* browser_context_;
-    bool waiting_;
-  };
-
   // A helper class to wait for an views::Widget to become activated.
   class WidgetActivatedWaiter : public views::WidgetObserver {
    public:
     explicit WidgetActivatedWaiter(views::Widget* widget)
         : widget_(widget), waiting_(false) {
       widget_->AddObserver(this);
     }
     ~WidgetActivatedWaiter() override { widget_->RemoveObserver(this); }
 
     void ActivateAndWait() {
@@ skipping 19 matching lines @@
   };
 
   scoped_refptr<Extension> extension_;
 };
 
 void ExtensionWindowLastFocusedTest::SetUpOnMainThread() {
   ExtensionTabsTest::SetUpOnMainThread();
   extension_ = test_util::CreateEmptyExtension();
 }
 
-void ExtensionWindowLastFocusedTest::ActivateAppWindow(AppWindow* app_window) {
-  AppWindowActivatedWaiter waiter(app_window, browser()->profile());
-  waiter.ActivateAndWait();
-}
-
 void ExtensionWindowLastFocusedTest::ActivateBrowserWindow(Browser* browser) {
   BrowserView* view = BrowserView::GetBrowserViewForBrowser(browser);
   EXPECT_NE(nullptr, view);
   views::Widget* widget = view->frame();
   EXPECT_NE(nullptr, widget);
   WidgetActivatedWaiter waiter(widget);
   waiter.ActivateAndWait();
 }
 
 Browser* ExtensionWindowLastFocusedTest::CreateBrowserWithEmptyTab(
@@ skipping 76 matching lines @@
     EXPECT_NE(devtools_window_id,
               api_test_utils::GetInteger(result.get(), "id"));
   }
 
   AppWindow* app_window = CreateTestAppWindow(
       "{\"outerBounds\": "
       "{\"width\": 300, \"height\": 300,"
       " \"minWidth\": 200, \"minHeight\": 200,"
       " \"maxWidth\": 400, \"maxHeight\": 400}}");
   {
-    ActivateAppWindow(app_window);
+    apps::AppWindowWaiter waiter(AppWindowRegistry::Get(browser()->profile()),
+                                 app_window->extension_id());
+    waiter.WaitForActivated();
 
     scoped_refptr<WindowsGetLastFocusedFunction> get_current_app_function =
         new WindowsGetLastFocusedFunction();
     std::unique_ptr<base::DictionaryValue> result(utils::ToDictionary(
         RunFunction(get_current_app_function.get(), "[{\"populate\": true}]")));
     int app_window_id = app_window->session_id().id();
     EXPECT_NE(app_window_id, api_test_utils::GetInteger(result.get(), "id"));
   }
 
   DevToolsWindowTesting::CloseDevToolsWindowSync(devtools);
@@ skipping 51 matching lines @@
     EXPECT_EQ(-1, GetTabId(result.get()));
     EXPECT_EQ("devtools", api_test_utils::GetString(result.get(), "type"));
   }
 
   AppWindow* app_window = CreateTestAppWindow(
       "{\"outerBounds\": "
       "{\"width\": 300, \"height\": 300,"
       " \"minWidth\": 200, \"minHeight\": 200,"
       " \"maxWidth\": 400, \"maxHeight\": 400}}");
   {
-    ActivateAppWindow(app_window);
+    apps::AppWindowWaiter waiter(AppWindowRegistry::Get(browser()->profile()),
+                                 app_window->extension_id());
+    waiter.WaitForActivated();
 
     scoped_refptr<WindowsGetLastFocusedFunction> get_current_app_function =
         new WindowsGetLastFocusedFunction();
     std::unique_ptr<base::DictionaryValue> result(utils::ToDictionary(
         RunFunction(get_current_app_function.get(),
                     "[{\"populate\": true, \"windowTypes\": [ \"app\" ]}]")));
     int app_window_id = app_window->session_id().id();
     EXPECT_EQ(app_window_id, api_test_utils::GetInteger(result.get(), "id"));
     EXPECT_EQ(-1, GetTabId(result.get()));
     EXPECT_EQ("app", api_test_utils::GetString(result.get(), "type"));
@@ skipping 1090 matching lines @@
   EXPECT_EQ(first_web_contents,
             browser()->tab_strip_model()->GetActiveWebContents());
   browser()->tab_strip_model()->ActivateTabAt(1, true);
   EXPECT_EQ(second_web_contents,
             browser()->tab_strip_model()->GetActiveWebContents());
 
   EXPECT_EQ(url, second_web_contents->GetVisibleURL());
 }
 
 }  // namespace extensions