Remove user-related data from local_state and add to user_preferences, i...

chrome/browser/ui/window_sizer.cc

 // Copyright (c) 2010 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.h"
 
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/pref_names.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 // 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::string& app_name, Browser* browser)
-      : app_name_(app_name),
-        browser_(browser) {
+  explicit DefaultStateProvider(const std::string& app_name,
+      const Browser* browser) : app_name_(app_name),
+                                browser_(browser) {
   }
 
   // Overridden from WindowSizer::StateProvider:
   virtual bool GetPersistentState(gfx::Rect* bounds,
                                   bool* maximized,
                                   gfx::Rect* work_area) const {
     DCHECK(bounds && maximized);
 
     std::string key(prefs::kBrowserWindowPlacement);
     if (!app_name_.empty()) {
       key.append("_");
       key.append(app_name_);
     }
 
-    if (!g_browser_process->local_state())
+    if (!browser_->profile()->GetPrefs())
       return false;
 
     const DictionaryValue* wp_pref =
-        g_browser_process->local_state()->GetDictionary(key.c_str());
+        browser_->profile()->GetPrefs()->GetDictionary(key.c_str());
     int top = 0, left = 0, bottom = 0, right = 0;
     bool has_prefs =
         wp_pref &&
         wp_pref->GetInteger("top", &top) &&
         wp_pref->GetInteger("left", &left) &&
         wp_pref->GetInteger("bottom", &bottom) &&
         wp_pref->GetInteger("right", &right) &&
         wp_pref->GetBoolean("maximized", maximized);
     bounds->SetRect(left, top, std::max(0, right - left),
                     std::max(0, bottom - top));
@@ skipping 16 matching lines @@
   }
 
   virtual bool GetLastActiveWindowState(gfx::Rect* bounds) const {
     // Applications are always restored with the same position.
     if (!app_name_.empty())
       return false;
 
     // If a reference browser is set, use its window. Otherwise find last
     // active.
     BrowserWindow* window = NULL;
-    if (browser_) {
+    // Window may be null if browser is just starting up.
+    if (browser_ && browser_->window()) {
       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->GetRestoredBounds();
       return true;
     }
 
     return false;
   }
 
  private:
   std::string app_name_;
 
   // If set, is used as the reference browser for GetLastActiveWindowState.
-  Browser* browser_;
+  const Browser* browser_;
   DISALLOW_COPY_AND_ASSIGN(DefaultStateProvider);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // MonitorInfoProvider, public:
 
 WindowSizer::MonitorInfoProvider::MonitorInfoProvider() {}
 
 WindowSizer::MonitorInfoProvider::~MonitorInfoProvider() {}
 
 ///////////////////////////////////////////////////////////////////////////////
 // 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::string& app_name,
                                          const gfx::Rect& specified_bounds,
-                                         Browser* browser,
+                                         const Browser* browser,
                                          gfx::Rect* window_bounds,
                                          bool* maximized) {
   const WindowSizer sizer(new DefaultStateProvider(app_name, browser),
                           CreateDefaultMonitorInfoProvider());
   sizer.DetermineWindowBounds(specified_bounds, window_bounds, maximized);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WindowSizer, private:
 
@@ skipping 181 matching lines @@
   // On non-Mac platforms, we are less aggressive about repositioning.  Simply
   // ensure that at least kMinVisibleWidth * kMinVisibleHeight is visible.
   const int min_y = work_area.y() + kMinVisibleHeight - bounds->height();
   const int min_x = work_area.x() + kMinVisibleWidth - bounds->width();
   const int max_y = work_area.bottom() - kMinVisibleHeight;
   const int max_x = work_area.right() - kMinVisibleWidth;
   bounds->set_y(std::max(min_y, std::min(max_y, bounds->y())));
   bounds->set_x(std::max(min_x, std::min(max_x, bounds->x())));
 #endif  // defined(OS_MACOSX)
 }