PART1: Initiated the SignedSettings refactoring.

chrome/browser/chromeos/cros_settings.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_CROS_SETTINGS_H_
 #define CHROME_BROWSER_CHROMEOS_CROS_SETTINGS_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include "base/hash_tables.h"
 #include "base/memory/singleton.h"
 #include "base/observer_list.h"
 #include "base/threading/non_thread_safe.h"
 #include "chrome/browser/chromeos/cros_settings_names.h"
+#include "chrome/browser/chromeos/cros_settings_provider.h"
 #include "content/common/notification_observer.h"
 
 namespace base {
 template <typename T> struct DefaultLazyInstanceTraits;
 class Value;
+class ListValue;
 }
 
 namespace chromeos {
 
-class CrosSettingsProvider;
-
 // A class manages per-device/global settings.
 class CrosSettings : public base::NonThreadSafe {
  public:
   // Class factory.
   static CrosSettings* Get();
 
   // Helper function to test if given path is a value cros settings name.

[Mattias Nissler (ping if slow), 2011/09/21 11:12:59]

why is this public?

[pastarmovj, 2011/09/23 15:19:32]

Because the CoreChromeOSOptionsHandler uses it to decide if it should handle a
pref from the CrosSettings or from the normal PrefStore.

See: core_chromeos_options_handler.cc

   static bool IsCrosSettings(const std::string& path);
 
   // Sets |in_value| to given |path| in cros settings.
   // Note that this takes ownership of |in_value|.
   void Set(const std::string& path, base::Value* in_value);
 
   // Fires system setting change notification.
   void FireObservers(const char* path);

[Mattias Nissler (ping if slow), 2011/09/21 11:12:59]

why is this public?

[pastarmovj, 2011/09/23 15:19:32]

Right now this is used by the SignedSettingsOps to signal changes to the
observers of the CrosSettings. I will consider refactoring this once I refactor
the Ops.

 
   // Gets settings value of given |path| to |out_value|.

[Mattias Nissler (ping if slow), 2011/09/21 11:12:59]

So there's no way of distinguishing "not set" from "not available"?

[pastarmovj, 2011/09/23 15:19:32]

What would the difference be for signed settings. We don't have default values
so the not present is not set at the same time. If you mean distinguishing
between bogus name and a  legitimate cros policy name you can use the
IsCrosSettings method above to check that or check the return value of
GetProvider against NULL for that too.

[Mattias Nissler (ping if slow), 2011/09/26 17:26:37]

I'm not sure I understand your reply. What I meant that a NULL return value
could either indicate that the setting is actually not present in the device
settings, or that device settings haven't been loaded yet and thus the value is
not available yet. I'm aware there's GetTrusted() to handle the latter, but some
callers might just be interested whether the value is the actual value from
device settings?

+  const base::Value* GetPref(const std::string& path) const;
+
+  // Gets settings value of given |path| to |out_value|.
   // Note that the caller owns |out_value| returned.
   bool Get(const std::string& path, base::Value** out_value) const;
 
+  // Gets settings value of given |path| from the trusted store. It will call
+  // the |callback| function with the value of the setting or NULL if it could
+  // not be retrieved.
+  bool GetTrusted(const std::string& path,
+                  const CrosSettingsProvider::Callback& callback) const;

[Mattias Nissler (ping if slow), 2011/09/21 11:12:59]

Clients shouldn't need to depend on CrosSettingsProvider. Can we declare the
callback type in CrosSettings?

[pastarmovj, 2011/09/23 15:19:32]

Replaced with base::Closure which it ended up being.

+
   // Convenience forms of Set().  These methods will replace any existing
   // value at that path, even if it has a different type.
   void SetBoolean(const std::string& path, bool in_value);
   void SetInteger(const std::string& path, int in_value);
   void SetDouble(const std::string& path, double in_value);
   void SetString(const std::string& path, const std::string& in_value);
 
   // These are convenience forms of Get().  The value will be retrieved
   // and the return value will be true if the path is valid and the value at
   // the end of the path can be returned in the form specified.
   bool GetBoolean(const std::string& path, bool* out_value) const;
   bool GetInteger(const std::string& path, int* out_value) const;
   bool GetDouble(const std::string& path, double* out_value) const;
   bool GetString(const std::string& path, std::string* out_value) const;
+  bool GetList(const std::string& path,
+               const base::ListValue** out_value) const;
 
   // adding/removing of providers
   bool AddSettingsProvider(CrosSettingsProvider* provider);
   bool RemoveSettingsProvider(CrosSettingsProvider* provider);
 
   // If the pref at the given path changes, we call the observer's Observe
   // method with PREF_CHANGED.
   void AddSettingsObserver(const char* path, NotificationObserver* obs);
   void RemoveSettingsObserver(const char* path, NotificationObserver* obs);
 
@@ skipping 14 matching lines @@
   CrosSettings();
   ~CrosSettings();
   friend struct base::DefaultLazyInstanceTraits<CrosSettings>;
 
   DISALLOW_COPY_AND_ASSIGN(CrosSettings);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_CROS_SETTINGS_H_