Fix the browser match rules.

chrome/browser/ui/ash/launcher/chrome_launcher_controller_unittest.cc

 // Copyright 2013 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 "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 600 matching lines @@
 
   ExtensionService* extension_service_;
 
   ash::ShelfItemDelegateManager* item_delegate_manager_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerTest);
 };
 
 #if defined(OS_CHROMEOS)
-// A browser window proxy which is able to associate an aura native window with
-// it.
-class TestBrowserWindowAura : public TestBrowserWindow {
- public:
-  // |native_window| will still be owned by the caller after the constructor
-  // was called.
-  explicit TestBrowserWindowAura(aura::Window* native_window)
-      : native_window_(native_window) {
-  }
-  ~TestBrowserWindowAura() override {}
-
-  gfx::NativeWindow GetNativeWindow() const override {
-    return native_window_.get();
-  }
-
-  Browser* browser() { return browser_.get(); }
-
-  void CreateBrowser(const Browser::CreateParams& params) {
-    Browser::CreateParams create_params = params;
-    create_params.window = this;
-    browser_.reset(new Browser(create_params));
-  }
-
- private:
-  scoped_ptr<Browser> browser_;
-  scoped_ptr<aura::Window> native_window_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestBrowserWindowAura);
-};
-
-// Creates a test browser window which has a native window.
-scoped_ptr<TestBrowserWindowAura> CreateTestBrowserWindow(
-    const Browser::CreateParams& params) {
-  // Create a window.
-  aura::Window* window = new aura::Window(NULL);
-  window->set_id(0);
-  window->SetType(ui::wm::WINDOW_TYPE_NORMAL);
-  window->Init(ui::LAYER_TEXTURED);
-  window->Show();
-
-  scoped_ptr<TestBrowserWindowAura> browser_window(
-      new TestBrowserWindowAura(window));
-  browser_window->CreateBrowser(params);
-  return browser_window.Pass();
-}
 
 // Watches WebContents and blocks until it is destroyed. This is needed for
 // the destruction of a V2 application.
 class WebContentsDestroyedWatcher : public content::WebContentsObserver {
  public:
   explicit WebContentsDestroyedWatcher(content::WebContents* web_contents)
       : content::WebContentsObserver(web_contents),
         message_loop_runner_(new content::MessageLoopRunner) {
     EXPECT_TRUE(web_contents != NULL);
   }
@@ skipping 178 matching lines @@
     manager->SetAnimationSpeedForTest(
         chrome::MultiUserWindowManagerChromeOS::ANIMATION_SPEED_DISABLED);
     manager->ActiveUserChanged(name);
     launcher_controller_->browser_status_monitor_for_test()->
         ActiveUserChanged(name);
     launcher_controller_->app_window_controller_for_test()->
         ActiveUserChanged(name);
   }
 
   // Creates a browser with a |profile| and load a tab with a |title| and |url|.
-  Browser* CreateBrowserAndTabWithProfile(Profile* profile,
-                                          const std::string& title,
-                                          const std::string& url) {
+  scoped_ptr<Browser> CreateBrowserAndTabWithProfile(Profile* profile,
+                                                     const std::string& title,
+                                                     const std::string& url) {
     Browser::CreateParams params(profile, chrome::HOST_DESKTOP_TYPE_ASH);
-    Browser* browser = chrome::CreateBrowserWithTestWindowForParams(&params);
-    chrome::NewTab(browser);
+    scoped_ptr<Browser> browser =
+        chrome::CreateBrowserWithTestWindowForParams(&params);
+    chrome::NewTab(browser.get());
 
-    BrowserList::SetLastActive(browser);
-    NavigateAndCommitActiveTabWithTitle(
-        browser, GURL(url), ASCIIToUTF16(title));
-    return browser;
+    BrowserList::SetLastActive(browser.get());
+    NavigateAndCommitActiveTabWithTitle(browser.get(), GURL(url),
+                                        ASCIIToUTF16(title));
+    return browser.Pass();
   }
 
   // Creates a running V1 application.
   // Note that with the use of the app_tab_helper as done below, this is only
   // usable with a single v1 application.
   V1App* CreateRunningV1App(Profile* profile,
                             const std::string& app_name,
                             const std::string& url) {
     V1App* v1_app = new V1App(profile, app_name);
     // Create a new app tab helper and assign it to the launcher so that this
@@ skipping 590 matching lines @@
 
   // Add two users to the window manager.
   std::string user2 = "user2";
   TestingProfile* profile2 = CreateMultiUserProfile(user2);
   manager->AddUser(profile());
   manager->AddUser(profile2);
   const std::string& current_user =
       multi_user_util::GetUserIDFromProfile(profile());
 
   // Create a browser window with a native window for the current user.
-  scoped_ptr<BrowserWindow> browser_window(CreateTestBrowserWindow(
-      Browser::CreateParams(profile(), chrome::HOST_DESKTOP_TYPE_ASH)));
+  Browser::CreateParams params(profile(), chrome::HOST_DESKTOP_TYPE_ASH);
+  scoped_ptr<Browser> browser =
+      chrome::CreateBrowserWithAuraTestWindowForParams(nullptr, &params);
+  BrowserWindow* browser_window = browser->window();
   aura::Window* window = browser_window->GetNativeWindow();
   manager->SetWindowOwner(window, current_user);
 
   // Check that an activation of the window on its owner's desktop does not
   // change the visibility to another user.
-  launcher_controller_->ActivateWindowOrMinimizeIfActive(browser_window.get(),
-                                                         false);
+  launcher_controller_->ActivateWindowOrMinimizeIfActive(browser_window, false);
   EXPECT_TRUE(manager->IsWindowOnDesktopOfUser(window, current_user));
 
   // Transfer the window to another user's desktop and check that activating it
   // does pull it back to that user.
   manager->ShowWindowForUser(window,
                              multi_user_util::GetUserIDFromProfile(profile2));
   EXPECT_FALSE(manager->IsWindowOnDesktopOfUser(window, current_user));
-  launcher_controller_->ActivateWindowOrMinimizeIfActive(browser_window.get(),
-                                                         false);
+  launcher_controller_->ActivateWindowOrMinimizeIfActive(browser_window, false);
   EXPECT_TRUE(manager->IsWindowOnDesktopOfUser(window, current_user));
 }
 #endif
 
 // Check that lock -> pin -> unlock -> unpin does properly transition.
 TEST_F(ChromeLauncherControllerTest, CheckLockPinUnlockUnpin) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
@@ skipping 495 matching lines @@
   base::string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL("http://test1"), title1);
   base::string16 one_menu_item1[] = { title1 };
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_browser, 1, one_menu_item1, true));
 
   // Create a browser for another user and check that it is not included in the
   // users running browser list.
   std::string user2 = "user2";
   TestingProfile* profile2 = CreateMultiUserProfile(user2);
-  scoped_ptr<Browser> browser2(
-      CreateBrowserAndTabWithProfile(profile2, user2, "http://test2"));
+  scoped_ptr<Browser> browser2 =
+      CreateBrowserAndTabWithProfile(profile2, user2, "http://test2");
   base::string16 one_menu_item2[] = { ASCIIToUTF16(user2) };
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_browser, 1, one_menu_item1, true));
 
   // Switch to the other user and make sure that only that browser window gets
   // shown.
   SwitchActiveUser(profile2->GetProfileUserName());
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_browser, 1, one_menu_item2, true));
 
@@ skipping 659 matching lines @@
 
   EXPECT_EQ(1, app_icon_loader->fetch_count());
   ASSERT_EQ(initial_size + 1, model_->items().size());
   EXPECT_TRUE(launcher_controller_->IsAppPinned("1"));
   EXPECT_FALSE(launcher_controller_->IsAppPinned("0"));
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[app_index].type);
 
   launcher_controller_->UnpinAppWithID("1");
   ASSERT_EQ(initial_size, model_->items().size());
 }