Propagate more information about ValueStore errors to callers, notably an

chrome/browser/extensions/api/storage/policy_value_store.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/extensions/api/storage/policy_value_store.h"
 
 #include "base/logging.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/storage/settings_namespace.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/policy/policy_types.h"
 #include "chrome/browser/value_store/value_store_change.h"
+#include "chrome/browser/value_store/value_store_util.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
+namespace util = value_store_util;
+
 namespace extensions {
 
 namespace {
 
-const char kReadOnlyStoreErrorMessage[] = "This is a read-only store.";
-
-ValueStore::WriteResult WriteResultError() {
-  return ValueStore::MakeWriteResult(kReadOnlyStoreErrorMessage);
+scoped_ptr<ValueStore::Error> ReadOnlyError(scoped_ptr<std::string> key) {
+  return make_scoped_ptr(new ValueStore::Error(
+      ValueStore::READ_ONLY, "This is a read-only store.", key.Pass()));
 }
 
 }  // namespace
 
 PolicyValueStore::PolicyValueStore(
     const std::string& extension_id,
     const scoped_refptr<SettingsObserverList>& observers,
     scoped_ptr<ValueStore> delegate)
     : extension_id_(extension_id),
       observers_(observers),
@@ skipping 16 matching lines @@
   }
 
   // Get the previous policies stored in the database.
   // TODO(joaodasilva): it'd be better to have a less expensive way of
   // determining which keys are currently stored, or of determining which keys
   // must be removed.
   base::DictionaryValue previous_policy;
   ValueStore::ReadResult read_result = delegate_->Get();
   if (read_result->HasError()) {
     LOG(WARNING) << "Failed to read managed settings for extension "
-        << extension_id_ << ": " << read_result->error();
+        << extension_id_ << ": " << read_result->error().message;
     // Leave |previous_policy| empty, so that events are generated for every
     // policy in |current_policy|.
   } else {
-    read_result->settings()->Swap(&previous_policy);
+    read_result->settings().Swap(&previous_policy);
   }
 
   // Now get two lists of changes: changes after setting the current policies,
   // and changes after removing old policies that aren't in |current_policy|
   // anymore.
   std::vector<std::string> removed_keys;
   for (base::DictionaryValue::Iterator it(previous_policy);
        !it.IsAtEnd(); it.Advance()) {
     if (!current_policy.HasKey(it.key()))
       removed_keys.push_back(it.key());
@@ skipping 56 matching lines @@
     const std::vector<std::string>& keys) {
   return delegate_->Get(keys);
 }
 
 ValueStore::ReadResult PolicyValueStore::Get() {
   return delegate_->Get();
 }
 
 ValueStore::WriteResult PolicyValueStore::Set(
     WriteOptions options, const std::string& key, const base::Value& value) {
-  return WriteResultError();
+  return MakeWriteResult(ReadOnlyError(util::NewKey(key)));
 }
 
 ValueStore::WriteResult PolicyValueStore::Set(
     WriteOptions options, const base::DictionaryValue& settings) {
-  return WriteResultError();
+  return MakeWriteResult(ReadOnlyError(util::NoKey()));
 }
 
 ValueStore::WriteResult PolicyValueStore::Remove(const std::string& key) {
-  return WriteResultError();
+  return MakeWriteResult(ReadOnlyError(util::NewKey(key)));
 }
 
 ValueStore::WriteResult PolicyValueStore::Remove(
     const std::vector<std::string>& keys) {
-  return WriteResultError();
+  return MakeWriteResult(ReadOnlyError(util::NoKey()));
 }
 
 ValueStore::WriteResult PolicyValueStore::Clear() {
-  return WriteResultError();
+  return MakeWriteResult(ReadOnlyError(util::NoKey()));
 }
 
 }  // namespace extensions