Revert 72153 - Remove user-related data from local_state and add to user_pre...

chrome/browser/ui/browser.cc

 // Copyright (c) 2011 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/browser.h"
 
 #if defined(OS_WIN)
 #include <shellapi.h>
 #include <windows.h>
 #endif  // OS_WIN
@@ skipping 525 matching lines @@
     url = extension->GetFullLaunchURL();
   }
 
   std::string app_name;
   if (extension)
     app_name =
         web_app::GenerateApplicationNameFromExtensionId(extension->id());
   else
     app_name = web_app::GenerateApplicationNameFromURL(url);
 
-  RegisterAppPrefs(app_name, profile);
+  RegisterAppPrefs(app_name);
 
   bool as_panel = extension && (container == extension_misc::LAUNCH_PANEL);
 
   gfx::Size window_size;
   if (extension)
     window_size.SetSize(extension->launch_width(),
                         extension->launch_height());
 
   Browser* browser = Browser::CreateForApp(app_name, window_size, profile,
                                            as_panel);
@@ skipping 175 matching lines @@
     // In playback/record mode we always fix the size of the browser and
     // move it to (0,0).  The reason for this is two reasons:  First we want
     // resize/moves in the playback to still work, and Second we want
     // playbacks to work (as much as possible) on machines w/ different
     // screen sizes.
     return gfx::Rect(0, 0, 800, 600);
   }
 
   gfx::Rect restored_bounds = override_bounds_;
   bool maximized;
-  WindowSizer::GetBrowserWindowBounds(app_name_, restored_bounds, this,
+  WindowSizer::GetBrowserWindowBounds(app_name_, restored_bounds, NULL,
                                       &restored_bounds, &maximized);
   return restored_bounds;
 }
 
 // TODO(beng): obtain maximized state some other way so we don't need to go
 //             through all this hassle.
 bool Browser::GetSavedMaximizedState() const {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kStartMaximized))
     return true;
 
   if (maximized_state_ == MAXIMIZED_STATE_MAXIMIZED)
     return true;
   if (maximized_state_ == MAXIMIZED_STATE_UNMAXIMIZED)
     return false;
 
   // An explicit maximized state was not set. Query the window sizer.
   gfx::Rect restored_bounds;
   bool maximized = false;
-  WindowSizer::GetBrowserWindowBounds(app_name_, restored_bounds, this,
+  WindowSizer::GetBrowserWindowBounds(app_name_, restored_bounds, NULL,
                                       &restored_bounds, &maximized);
   return maximized;
 }
 
 SkBitmap Browser::GetCurrentPageIcon() const {
   TabContents* contents = GetSelectedTabContents();
   // |contents| can be NULL since GetCurrentPageIcon() is called by the window
   // during the window's creation (before tabs have been added).
   return contents ? contents->GetFavIcon() : SkBitmap();
 }
@@ skipping 1195 matching lines @@
   const PrefService::Preference* home_page_is_new_tab_page_pref =
       prefs->FindPreference(prefs::kHomePageIsNewTabPage);
   if (home_page_is_new_tab_page_pref &&
       !home_page_is_new_tab_page_pref->IsManaged() &&
       !prefs->HasPrefPath(prefs::kHomePageIsNewTabPage))
     prefs->SetBoolean(prefs::kHomePageIsNewTabPage, false);
 }
 
 // static
 void Browser::RegisterPrefs(PrefService* prefs) {
+  prefs->RegisterDictionaryPref(prefs::kBrowserWindowPlacement);
   prefs->RegisterIntegerPref(prefs::kOptionsWindowLastTabIndex, 0);
+  prefs->RegisterIntegerPref(prefs::kDevToolsSplitLocation, -1);
   prefs->RegisterDictionaryPref(prefs::kPreferencesWindowPlacement);
   prefs->RegisterIntegerPref(prefs::kExtensionSidebarWidth, -1);
-  prefs->RegisterIntegerPref(prefs::kMultipleProfilePrefMigration, 0);
   // Educated guess: Chrome has a bundled Flash version supporting
   // clearing LSO data, Chromium hasn't.
 #if defined(GOOGLE_CHROME_BUILD)
   prefs->RegisterBooleanPref(prefs::kClearPluginLSODataEnabled, true);
 #else
   prefs->RegisterBooleanPref(prefs::kClearPluginLSODataEnabled, false);
 #endif
 }
 
 // static
@@ skipping 27 matching lines @@
   prefs->RegisterBooleanPref(prefs::kShowOmniboxSearchHint, true);
   prefs->RegisterBooleanPref(prefs::kWebAppCreateOnDesktop, true);
   prefs->RegisterBooleanPref(prefs::kWebAppCreateInAppsMenu, true);
   prefs->RegisterBooleanPref(prefs::kWebAppCreateInQuickLaunchBar, true);
   prefs->RegisterBooleanPref(prefs::kUseVerticalTabs, false);
   prefs->RegisterBooleanPref(prefs::kEnableTranslate, true);
   prefs->RegisterBooleanPref(prefs::kRemotingHasSetupCompleted, false);
   prefs->RegisterStringPref(prefs::kCloudPrintEmail, std::string());
   prefs->RegisterBooleanPref(prefs::kDevToolsDisabled, false);
   prefs->RegisterRealPref(prefs::kDefaultZoomLevel, 0.0);
-  prefs->RegisterIntegerPref(prefs::kDevToolsSplitLocation, -1);
-  prefs->RegisterDictionaryPref(prefs::kBrowserWindowPlacement);
+  prefs->RegisterIntegerPref(prefs::kMultipleProfilePrefMigration, 0);
   // We need to register the type of this preference in order to query
   // it even though it's only typically controlled via policy.
   prefs->RegisterBooleanPref(prefs::kDisable3DAPIs, false);
 }
 
 // static
 bool Browser::RunUnloadEventsHelper(TabContents* contents) {
   // If the TabContents is not connected yet, then there's no unload
   // handler we can fire even if the TabContents has an unload listener.
   // One case where we hit this is in a tab that has an infinite loop
@@ skipping 917 matching lines @@
   return false;
 }
 
 bool Browser::IsApplication() const {
   return (type_ & TYPE_APP) != 0;
 }
 
 void Browser::ConvertContentsToApplication(TabContents* contents) {
   const GURL& url = contents->controller().GetActiveEntry()->url();
   std::string app_name = web_app::GenerateApplicationNameFromURL(url);
-  RegisterAppPrefs(app_name, contents->profile());
+  RegisterAppPrefs(app_name);
 
   DetachContents(contents);
   Browser* app_browser = Browser::CreateForApp(
       app_name, gfx::Size(), profile_, false);
   TabContentsWrapper* wrapper = new TabContentsWrapper(contents);
   app_browser->tabstrip_model()->AppendTabContents(wrapper, true);
 
   contents->GetMutableRendererPrefs()->can_accept_load_drops = false;
   contents->render_view_host()->SyncRendererPrefs();
   app_browser->window()->Show();
@@ skipping 1133 matching lines @@
     // us). Avoid that by passing in false so that the call to
     // ProcessPendingTabs is delayed.
     ClearUnloadState(contents->tab_contents(), false);
   }
 
   registrar_.Remove(this, NotificationType::TAB_CONTENTS_DISCONNECTED,
                     Source<TabContentsWrapper>(contents));
 }
 
 // static
-void Browser::RegisterAppPrefs(const std::string& app_name, Profile* profile) {
+void Browser::RegisterAppPrefs(const std::string& app_name) {
   // A set of apps that we've already started.
   static std::set<std::string>* g_app_names = NULL;
 
   if (!g_app_names)
     g_app_names = new std::set<std::string>;
 
   // Only register once for each app name.
   if (g_app_names->find(app_name) != g_app_names->end())
     return;
   g_app_names->insert(app_name);
 
   // We need to register the window position pref.
   std::string window_pref(prefs::kBrowserWindowPlacement);
   window_pref.append("_");
   window_pref.append(app_name);
-  profile->GetPrefs()->RegisterDictionaryPref(window_pref.c_str());
+  PrefService* prefs = g_browser_process->local_state();
+  DCHECK(prefs);
+
+  prefs->RegisterDictionaryPref(window_pref.c_str());
 }
 
 void Browser::TabRestoreServiceChanged(TabRestoreService* service) {
   command_updater_.UpdateCommandEnabled(IDC_RESTORE_TAB,
                                         !service->entries().empty());
 }
 
 void Browser::TabRestoreServiceDestroyed(TabRestoreService* service) {
   if (!tab_restore_service_)
     return;
@@ skipping 111 matching lines @@
     // The page transition below is only for the purpose of inserting the tab.
     browser->AddTab(view_source_contents, PageTransition::LINK);
   }
 
   if (profile_->HasSessionService()) {
     SessionService* session_service = profile_->GetSessionService();
     if (session_service)
       session_service->TabRestored(&view_source_contents->controller(), false);
   }
 }