Propagate more information about ValueStore errors to callers, notably an

chrome/browser/extensions/api/storage/storage_api.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/storage_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/storage/settings_frontend.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extensions_quota_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/storage.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace extensions {
 
 using content::BrowserThread;
 
-namespace {
-const char kUnsupportedArgumentType[] = "Unsupported argument type";
-const char kInvalidNamespaceErrorMessage[] =
-    "\"%s\" is not available in this instance of Chrome";
-const char kManagedNamespaceDisabledErrorMessage[] =
-    "\"managed\" is disabled. Use \"--%s\" to enable it.";
-const char kStorageErrorMessage[] = "Storage error";
-}  // namespace
-
 // SettingsFunction
 
 SettingsFunction::SettingsFunction()
     : settings_namespace_(settings_namespace::INVALID) {}
 
 SettingsFunction::~SettingsFunction() {}
 
 bool SettingsFunction::ShouldSkipQuotaLimiting() const {
   // Only apply quota if this is for sync storage.
   std::string settings_namespace_string;
   if (!args_->GetString(0, &settings_namespace_string)) {
-    // This is an error but it will be caught in RunImpl(), there is no
-    // mechanism to signify an error from this function.
+    // This should be EXTENSION_FUNCTION_VALIDATE(false) but there is no way
+    // to signify that from this function. It will be caught in RunImpl().
     return false;
   }
   return settings_namespace_string != "sync";
 }
 
 bool SettingsFunction::RunImpl() {
   std::string settings_namespace_string;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &settings_namespace_string));
   args_->Remove(0, NULL);
   settings_namespace_ =
       settings_namespace::FromString(settings_namespace_string);
   EXTENSION_FUNCTION_VALIDATE(
       settings_namespace_ != settings_namespace::INVALID);
 
   SettingsFrontend* frontend =
       profile()->GetExtensionService()->settings_frontend();
   if (!frontend->IsStorageEnabled(settings_namespace_)) {
-    error_ = base::StringPrintf(kInvalidNamespaceErrorMessage,
-                                settings_namespace_string.c_str());
+    error_ = base::StringPrintf(
+        "\"%s\" is not available in this instance of Chrome",
+        settings_namespace_string.c_str());
     return false;
   }
 
   observers_ = frontend->GetObservers();
   frontend->RunWithStorage(
       extension_id(),
       settings_namespace_,
       base::Bind(&SettingsFunction::AsyncRunWithStorage, this));
   return true;
 }
 
 void SettingsFunction::AsyncRunWithStorage(ValueStore* storage) {
   bool success = RunWithStorage(storage);
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&SettingsFunction::SendResponse, this, success));
 }
 
-bool SettingsFunction::UseReadResult(ValueStore::ReadResult result) {
-  if (result->HasError()) {
-    error_ = result->error();
+bool SettingsFunction::UseReadResult(ValueStore::ReadResult read_result) {
+  if (read_result->HasError()) {
+    error_ = read_result->error().message;
     return false;
   }
 
-  SetResult(result->settings().release());
+  base::DictionaryValue* result = new base::DictionaryValue();
+  result->Swap(&read_result->settings());
+  SetResult(result);
   return true;
 }
 
 bool SettingsFunction::UseWriteResult(ValueStore::WriteResult result) {
   if (result->HasError()) {
-    error_ = result->error();
+    error_ = result->error().message;
     return false;
   }
 
   if (!result->changes().empty()) {
     observers_->Notify(
         &SettingsObserver::OnSettingsChanged,
         extension_id(),
         settings_namespace_,
         ValueStoreChange::ToJson(result->changes()));
   }
@@ skipping 78 matching lines @@
     }
 
     case base::Value::TYPE_DICTIONARY: {
       base::DictionaryValue* as_dict = static_cast<base::DictionaryValue*>(input);
       ValueStore::ReadResult result = storage->Get(GetKeys(*as_dict));
       if (result->HasError()) {
         return UseReadResult(result.Pass());
       }
 
       base::DictionaryValue* with_default_values = as_dict->DeepCopy();
-      with_default_values->MergeDictionary(result->settings().get());
+      with_default_values->MergeDictionary(&result->settings());
       return UseReadResult(
-          ValueStore::MakeReadResult(with_default_values));
+          ValueStore::MakeReadResult(make_scoped_ptr(with_default_values)));
     }
 
     default:
-      return UseReadResult(
-          ValueStore::MakeReadResult(kUnsupportedArgumentType));
+      EXTENSION_FUNCTION_VALIDATE(false);
+      return false;
   }
 }
 
 bool StorageStorageAreaGetBytesInUseFunction::RunWithStorage(
     ValueStore* storage) {
   base::Value* input = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &input));
 
   size_t bytes_in_use = 0;
 
@@ skipping 11 matching lines @@
 
     case base::Value::TYPE_LIST: {
       std::vector<std::string> as_string_list;
       AddAllStringValues(*static_cast<base::ListValue*>(input),
                          &as_string_list);
       bytes_in_use = storage->GetBytesInUse(as_string_list);
       break;
     }
 
     default:
-      error_ = kUnsupportedArgumentType;
+      EXTENSION_FUNCTION_VALIDATE(false);
       return false;
   }
 
   SetResult(new base::FundamentalValue(static_cast<int>(bytes_in_use)));
   return true;
 }
 
 bool StorageStorageAreaSetFunction::RunWithStorage(ValueStore* storage) {
   base::DictionaryValue* input = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &input));
@@ skipping 17 matching lines @@
     }
 
     case base::Value::TYPE_LIST: {
       std::vector<std::string> as_string_list;
       AddAllStringValues(*static_cast<base::ListValue*>(input),
                          &as_string_list);
       return UseWriteResult(storage->Remove(as_string_list));
     }
 
     default:
-      return UseWriteResult(
-          ValueStore::MakeWriteResult(kUnsupportedArgumentType));
+      EXTENSION_FUNCTION_VALIDATE(false);
+      return false;
   };
 }
 
 void StorageStorageAreaRemoveFunction::GetQuotaLimitHeuristics(
     QuotaLimitHeuristics* heuristics) const {
   GetModificationQuotaLimitHeuristics(heuristics);
 }
 
 bool StorageStorageAreaClearFunction::RunWithStorage(ValueStore* storage) {
   return UseWriteResult(storage->Clear());
 }
 
 void StorageStorageAreaClearFunction::GetQuotaLimitHeuristics(
     QuotaLimitHeuristics* heuristics) const {
   GetModificationQuotaLimitHeuristics(heuristics);
 }
 
 }  // namespace extensions