No longer register app window placement preference keys on the fly.

chrome/browser/ui/browser_window_state.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/browser_window_state.h"
 
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
+#include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/window_sizer/window_sizer.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 
@@ skipping 14 matching lines @@
   int num2 = 0;
   if (!base::StringToInt(str.substr(0, num1_size), &num1) ||
       !base::StringToInt(str.substr(num2_pos, num2_size), &num2))
     return false;
 
   *ret_num1 = num1;
   *ret_num2 = num2;
   return true;
 }
 
+class WindowPlacementPrefUpdate : public DictionaryPrefUpdate {
+ public:
+  WindowPlacementPrefUpdate(PrefService* service,
+                            const std::string& window_name)
+      : DictionaryPrefUpdate(service, prefs::kAppWindowPlacement),
+        window_name_(window_name) {}
+
+  virtual ~WindowPlacementPrefUpdate() {}
+
+  virtual base::DictionaryValue* Get() OVERRIDE {
+    base::DictionaryValue* all_apps_dict = DictionaryPrefUpdate::Get();
+    base::DictionaryValue* this_app_dict = NULL;
+    if (!all_apps_dict->GetDictionary(window_name_, &this_app_dict)) {
+      this_app_dict = new base::DictionaryValue;
+      all_apps_dict->Set(window_name_, this_app_dict);
+    }
+    return this_app_dict;
+  }
+
+ private:
+  const std::string window_name_;
+
+  DISALLOW_COPY_AND_ASSIGN(WindowPlacementPrefUpdate);
+};
+
 }  // namespace
 
-std::string GetWindowPlacementKey(const Browser* browser) {
+std::string GetWindowName(const Browser* browser) {
   if (browser->app_name().empty()) {
     return browser->is_type_popup() ?
         prefs::kBrowserWindowPlacementPopup : prefs::kBrowserWindowPlacement;
   }
-  return std::string(prefs::kBrowserWindowPlacement) + "_" +
-      browser->app_name();
+  return browser->app_name();
+}
+
+scoped_ptr<DictionaryPrefUpdate> GetWindowPlacementDictionaryReadWrite(
+    const std::string& window_name,
+    PrefService* prefs) {
+  DCHECK(!window_name.empty());
+  if (prefs->FindPreference(window_name.c_str())) {

[gab, 2014/09/08 21:29:26]

Add a comment here about the fact that you're first looking for non-app windows
(i.e. browser/popup) as I was confused by this originally even in the context of
this CL.

[dgrogan, 2014/09/09 03:15:44]

Done.

+    return make_scoped_ptr(
+        new DictionaryPrefUpdate(prefs, window_name.c_str()));
+  }
+  return make_scoped_ptr(new WindowPlacementPrefUpdate(prefs, window_name))
+      .PassAs<DictionaryPrefUpdate>();
+}
+
+const base::DictionaryValue* GetWindowPlacementDictionaryReadOnly(
+    const Browser* browser) {
+  if (browser->app_name().empty()) {
+    const char* entry = browser->is_type_popup() ?
+        prefs::kBrowserWindowPlacementPopup : prefs::kBrowserWindowPlacement;
+    return browser->profile()->GetPrefs()->GetDictionary(entry);
+  }
+  const base::DictionaryValue* app_windows =
+      browser->profile()->GetPrefs()->GetDictionary(prefs::kAppWindowPlacement);
+  if (!app_windows)
+    return NULL;
+  const base::DictionaryValue* to_return = NULL;
+  app_windows->GetDictionary(browser->app_name(), &to_return);
+  return to_return;
 }
 
 bool ShouldSaveWindowPlacement(const Browser* browser) {
   // Only save the window placement of popups if the window is from a trusted
   // source (v1 app, devtools, or system window).
   return (browser->type() == Browser::TYPE_TABBED) ||
     ((browser->type() == Browser::TYPE_POPUP) && browser->is_trusted_source());
 }
 
 void SaveWindowPlacement(const Browser* browser,
@@ skipping 45 matching lines @@
   if (parsed_command_line.HasSwitch(switches::kWindowPosition)) {
     std::string str =
         parsed_command_line.GetSwitchValueASCII(switches::kWindowPosition);
     int x, y;
     if (ParseCommaSeparatedIntegers(str, &x, &y))
       bounds->set_origin(gfx::Point(x, y));
   }
 }
 
 }  // namespace chrome