Consolidate Browser Creation.

chrome/browser/ui/window_sizer/window_sizer_ash_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 "chrome/browser/ui/window_sizer/window_sizer.h"
 
 #include <vector>
 
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/test_shell_delegate.h"
 #include "ash/wm/window_resizer.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/window_sizer/window_sizer_common_unittest.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/test_browser_window.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/render_view_test.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKit.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/test_windows.h"
 
-
 namespace {
 
 typedef ash::test::AshTestBase WindowSizerTest;
 
 // A special test class for use with browser creation - it will create a
 // browser thread and deletes it after all other things have been destroyed.
 class WindowSizerTestWithBrowser : public WindowSizerTest {
  public:
   WindowSizerTestWithBrowser();
   virtual ~WindowSizerTestWithBrowser();
@@ skipping 13 matching lines @@
       new content::TestBrowserThread(content::BrowserThread::UI, ui_loop));
 }
 
 WindowSizerTestWithBrowser::~WindowSizerTestWithBrowser() {
 }
 
 // A browser window proxy which is able to associate an aura native window with
 // it.
 class TestBrowserWindowAura : public TestBrowserWindow {
  public:
-  TestBrowserWindowAura(Browser* browser, aura::Window* native_window);
+  explicit TestBrowserWindowAura(aura::Window* native_window);
   virtual ~TestBrowserWindowAura();
 
   virtual gfx::NativeWindow GetNativeWindow() OVERRIDE {
     return native_window_;
   }
 
  private:
   gfx::NativeWindow native_window_;
 
   DISALLOW_COPY_AND_ASSIGN(TestBrowserWindowAura);
 };
 
 } // namespace
 
-TestBrowserWindowAura::TestBrowserWindowAura(
-    Browser* browser,
-    aura::Window *native_window)
-    : TestBrowserWindow(browser),
-      native_window_(native_window) {
+TestBrowserWindowAura::TestBrowserWindowAura(aura::Window *native_window)
+    : native_window_(native_window) {
 }
 
 TestBrowserWindowAura::~TestBrowserWindowAura() {}
 
 // Test that the window is sized appropriately for the first run experience
 // where the default window bounds calculation is invoked.
 TEST_F(WindowSizerTest, DefaultSizeCase) {
   int grid = ash::Shell::GetInstance()->GetGridSize();
   EXPECT_EQ(WindowSizer::kDesktopBorderSize, grid);
   { // 4:3 monitor case, 1024x768, no taskbar
@@ skipping 521 matching lines @@
   scoped_ptr<aura::Window> popup(
       aura::test::CreateTestWindowWithId(1, default_container));
   popup->SetBounds(gfx::Rect(16, 32, 128, 256));
 
   scoped_ptr<aura::Window> panel(
       aura::test::CreateTestWindowWithId(2, default_container));
   panel->SetBounds(gfx::Rect(32, 48, 256, 512));
 
   // Create a browser which we can use to pass into the GetWindowBounds
   // function.
-  scoped_ptr<TestingProfile> profile;
-  profile.reset(new TestingProfile());
-  scoped_ptr<Browser> browser;
+  scoped_ptr<TestingProfile> profile(new TestingProfile());
   // Creating a popup handler here to make sure it does not interfere with the
   // existing windows.
-  browser.reset(new Browser(Browser::TYPE_TABBED, profile.get()));
+  scoped_ptr<Browser> browser(
+      chrome::CreateBrowserWithTestWindowForProfile(profile.get()));
 
-  scoped_ptr<Browser> window_owning_browser;
   // Creating a popup handler here to make sure it does not interfere with the
   // existing windows.
-  window_owning_browser.reset(new Browser(Browser::TYPE_TABBED,
-                                          profile.get()));
-  scoped_ptr<BrowserWindow> browser_window;
-  browser_window.reset(new TestBrowserWindowAura(window_owning_browser.get(),
-                                                 window.get()));
-  window_owning_browser->SetWindowForTesting(browser_window.get());
+  scoped_ptr<BrowserWindow> browser_window(
+      new TestBrowserWindowAura(window.get()));
+  Browser::CreateParams window_params(profile.get());
+  window_params.window = browser_window.get();
+  scoped_ptr<Browser> window_owning_browser(new Browser(window_params));
 
-  scoped_ptr<Browser> popup_owning_browser;
   // Creating a popup to make sure it does not interfere with the positioning.
-  popup_owning_browser.reset(new Browser(Browser::TYPE_POPUP,
-                                          profile.get()));
-  scoped_ptr<BrowserWindow> browser_popup;
-  browser_popup.reset(new TestBrowserWindowAura(popup_owning_browser.get(),
-                                                popup.get()));
-  popup_owning_browser->SetWindowForTesting(browser_popup.get());
+  scoped_ptr<BrowserWindow> browser_popup(
+      new TestBrowserWindowAura(popup.get()));
+  Browser::CreateParams popup_params(Browser::TYPE_POPUP, profile.get());
+  popup_params.window = browser_popup.get();
+  scoped_ptr<Browser> popup_owning_browser(new Browser(popup_params));
 
-  scoped_ptr<Browser> panel_owning_browser;
   // Creating a panel to make sure it does not interfere with the positioning.
-  panel_owning_browser.reset(new Browser(Browser::TYPE_PANEL,
-                                          profile.get()));
-  scoped_ptr<BrowserWindow> browser_panel;
-  browser_panel.reset(new TestBrowserWindowAura(panel_owning_browser.get(),
-                                                panel.get()));
-  panel_owning_browser->SetWindowForTesting(browser_panel.get());
+  scoped_ptr<BrowserWindow> browser_panel(
+      new TestBrowserWindowAura(panel.get()));
+  Browser::CreateParams panel_params(Browser::TYPE_POPUP, profile.get());
+  panel_params.window = browser_panel.get();
+  scoped_ptr<Browser> panel_owning_browser(new Browser(panel_params));
 
   window->Show();
   { // With a shown window it's size should get returned.
     gfx::Rect window_bounds;
     GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
                     gfx::Rect(50, 100, 300, 150), bottom_nonprimary,
                     PERSISTED, &window_bounds, browser.get(), gfx::Rect());
     EXPECT_EQ(gfx::Rect(16, 32, 640, 320), window_bounds);
   }
 
@@ skipping 43 matching lines @@
   }
 
   { // Check that a window which hangs out of the screen get moved back in.
     gfx::Rect window_bounds;
     GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), gfx::Rect(),
                     gfx::Rect(), DEFAULT, &window_bounds, NULL,
                     gfx::Rect(1020, 700, 100, 100));
     EXPECT_EQ(gfx::Rect(924, 668, 100, 100), window_bounds);
   }
 }