createWindow api call.

chrome/browser/window_sizer.cc

 // Copyright (c) 2006-2008 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/window_sizer.h"
 
 #include <atlbase.h>
 #include <atlapp.h>
 #include <atlmisc.h>
 
@@ skipping 70 matching lines @@
   }
 
   DISALLOW_COPY_AND_ASSIGN(DefaultMonitorInfoProvider);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // An implementation of WindowSizer::StateProvider that gets the last active
 // and persistent state from the browser window and the user's profile.
 class DefaultStateProvider : public WindowSizer::StateProvider {
  public:
-  explicit DefaultStateProvider(const std::wstring& app_name)
-      : app_name_(app_name) {
+  explicit DefaultStateProvider(const std::wstring& app_name, Browser* browser)
+      : app_name_(app_name),
+        browser_(browser) {
   }
 
   // Overridden from WindowSizer::StateProvider:
   virtual bool GetPersistentState(gfx::Rect* bounds, bool* maximized) const {
     DCHECK(bounds && maximized);
 
     std::wstring key(prefs::kBrowserWindowPlacement);
     if (!app_name_.empty()) {
       key.append(L"_");
       key.append(app_name_);
@@ skipping 15 matching lines @@
     bounds->SetRect(left, top, std::max(0, right - left),
                     std::max(0, bottom - top));
     return has_prefs;
   }
 
   virtual bool GetLastActiveWindowState(gfx::Rect* bounds) const {
     // Applications are always restored with the same position.
     if (!app_name_.empty())
       return false;
 
-    BrowserList::const_reverse_iterator it = BrowserList::begin_last_active();
-    BrowserList::const_reverse_iterator end = BrowserList::end_last_active();
-    for (; it != end; ++it) {
-      Browser* last_active = *it;
-      if (last_active && last_active->type() == Browser::TYPE_NORMAL) {
-        BrowserWindow* window = last_active->window();
-        DCHECK(window);
-        *bounds = window->GetNormalBounds();
-        return true;
+    // If a reference browser is set, use its window. Otherwise find last
+    // active.
+    BrowserWindow* window = NULL;
+    if (browser_) {
+      window = browser_->window();
+      DCHECK(window);
+    } else {
+      BrowserList::const_reverse_iterator it = BrowserList::begin_last_active();
+      BrowserList::const_reverse_iterator end = BrowserList::end_last_active();
+      for (; (it != end); ++it) {
+        Browser* last_active = *it;
+        if (last_active && last_active->type() == Browser::TYPE_NORMAL) {
+          window = last_active->window();
+          DCHECK(window);
+          break;
+        }
       }
     }
 
+    if (window) {
+      *bounds = window->GetNormalBounds();
+      return true;
+    }
+
     return false;
   }
 
  private:
   std::wstring app_name_;
 
+  // If set, is used as the reference browser for GetLastActiveWindowState.
+  Browser* browser_;
   DISALLOW_EVIL_CONSTRUCTORS(DefaultStateProvider);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // WindowSizer, public:
 
 WindowSizer::WindowSizer(
     StateProvider* state_provider,
     MonitorInfoProvider* monitor_info_provider) {
   Init(state_provider, monitor_info_provider);
 }
 
 WindowSizer::~WindowSizer() {
   if (state_provider_)
     delete state_provider_;
   if (monitor_info_provider_)
     delete monitor_info_provider_;
 }
 
 // static
 void WindowSizer::GetBrowserWindowBounds(const std::wstring& app_name,
                                          const gfx::Rect& specified_bounds,
+                                         Browser* browser,
                                          gfx::Rect* window_bounds,
                                          bool* maximized) {
-  const WindowSizer sizer(new DefaultStateProvider(app_name),
+  const WindowSizer sizer(new DefaultStateProvider(app_name, browser),
                           new DefaultMonitorInfoProvider);
   sizer.DetermineWindowBounds(specified_bounds, window_bounds, maximized);
 }
 
 gfx::Point WindowSizer::GetDefaultPopupOrigin(const gfx::Size& size) {
   RECT area;
   SystemParametersInfo(SPI_GETWORKAREA, 0, &area, 0);
   gfx::Point corner(area.left, area.top);
 
   if (Browser* b = BrowserList::GetLastActive()) {
@@ skipping 13 matching lines @@
       );
     }
   }
   return corner;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WindowSizer, private:
 
 WindowSizer::WindowSizer(const std::wstring& app_name) {
-  Init(new DefaultStateProvider(app_name),
+  Init(new DefaultStateProvider(app_name, NULL),
        new DefaultMonitorInfoProvider);
 }
 
 void WindowSizer::Init(StateProvider* state_provider,
                        MonitorInfoProvider* monitor_info_provider) {
   state_provider_ = state_provider;
   monitor_info_provider_ = monitor_info_provider;
 }
 
 void WindowSizer::DetermineWindowBounds(const gfx::Rect& specified_bounds,
@@ skipping 138 matching lines @@
   // Now that we've tried to correct the x/y position to something reasonable,
   // see if the window is still too tall or wide to fit, and resize it if need
   // be.
   if ((bottom_offscreen || top_offscreen) &&
       bounds->bottom() > work_area.bottom())
     bounds->set_height(work_area.height() - 2 * kWindowTilePixels);
   if ((left_offscreen || right_offscreen) &&
       bounds->right() > work_area.right())
     bounds->set_width(work_area.width() - 2 * kWindowTilePixels);
 }