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())) {
+    return make_scoped_ptr(
+        new DictionaryPrefUpdate(prefs, window_name.c_str()));
+  }
+  return make_scoped_ptr(new WindowPlacementPrefUpdate(prefs, window_name))

[gab, 2014/09/05 00:53:10]

Isn't the whole point of WindowPlacementPrefUpdate that it handles whether or
not the pref is present? If so, why also do this check in this method as opposed
to simply always returning a WindowPlacementPrefUpdate?

[dgrogan, 2014/09/06 00:47:06]

The check here is for kBrowserWindowPlacement and kBrowserWindowPlacementPopup,
which don't go in the new kAppWindowPlacement dictionary. The check in
WindowPlacementPrefUpdate is to look in the new dictionary to see if the apps'
sub dictionaries already exist.

+      .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