Extension Settings API: move the API functions into an object SettingsNamepace,

chrome/browser/extensions/settings/settings_api.cc

 // 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.
 
 #include "chrome/browser/extensions/settings/settings_api.h"
 
 #include "base/bind.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extensions_quota_service.h"
 #include "chrome/browser/extensions/settings/settings_api.h"
 #include "chrome/browser/extensions/settings/settings_frontend.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace extensions {
 
 using content::BrowserThread;
 
 namespace {
 const char* kUnsupportedArgumentType = "Unsupported argument type";
 }  // namespace
 
 // SettingsFunction
 
+SettingsFunction::SettingsFunction()
+    : settings_namespace_(settings_namespace::INVALID) {}
+
+SettingsFunction::~SettingsFunction() {}
+
 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::StringToNamespace(settings_namespace_string);
+    EXTENSION_FUNCTION_VALIDATE(
+        settings_namespace_ != settings_namespace::INVALID);
+  }
+
   SettingsFrontend* frontend =
       profile()->GetExtensionService()->settings_frontend();
+  observers_ = frontend->GetObservers();
   frontend->RunWithStorage(
       extension_id(),
-      base::Bind(
-          &SettingsFunction::RunWithStorageOnFileThread,
-          this,
-          frontend->GetObservers()));
+      settings_namespace_,
+      base::Bind(&SettingsFunction::RunWithStorageOnFileThread, this));
   return true;
 }
 
-void SettingsFunction::RunWithStorageOnFileThread(
-    scoped_refptr<SettingsObserverList> observers,
-    SettingsStorage* storage) {
+void SettingsFunction::RunWithStorageOnFileThread(SettingsStorage* storage) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  bool success = RunWithStorage(observers.get(), storage);
+  bool success = RunWithStorage(storage);
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&SettingsFunction::SendResponse, this, success));
 }
 
 bool SettingsFunction::UseReadResult(
     const SettingsStorage::ReadResult& result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (result.HasError()) {
     error_ = result.error();
     return false;
   }
 
   result_.reset(result.settings().DeepCopy());
   return true;
 }
 
 bool SettingsFunction::UseWriteResult(
-    scoped_refptr<SettingsObserverList> observers,
     const SettingsStorage::WriteResult& result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (result.HasError()) {
     error_ = result.error();
     return false;
   }
 
   if (!result.changes().empty()) {
-    observers->Notify(
+    observers_->Notify(
         &SettingsObserver::OnSettingsChanged,
         extension_id(),
+        settings_namespace_,
         SettingChange::GetEventJson(result.changes()));
   }
 
   return true;
 }
 
 // Concrete settings functions
 
 namespace {
 
@@ skipping 37 matching lines @@
   };
   heuristics->push_back(
       new ExtensionsQuotaService::SustainedLimit(
           base::TimeDelta::FromMinutes(10),
           shortLimitConfig,
           new QuotaLimitHeuristic::SingletonBucketMapper()));
 };
 
 }  // namespace
 
-bool GetSettingsFunction::RunWithStorage(
-    scoped_refptr<SettingsObserverList> observers,
-    SettingsStorage* storage) {
+bool GetSettingsFunction::RunWithStorage(SettingsStorage* storage) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   Value *input;
   EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &input));
 
   switch (input->GetType()) {
     case Value::TYPE_NULL:
       return UseReadResult(storage->Get());
 
     case Value::TYPE_STRING: {
       std::string as_string;
@@ skipping 20 matching lines @@
       return UseReadResult(
           SettingsStorage::ReadResult(with_default_values));
     }
 
     default:
       return UseReadResult(
           SettingsStorage::ReadResult(kUnsupportedArgumentType));
   }
 }
 
-bool SetSettingsFunction::RunWithStorage(
-    scoped_refptr<SettingsObserverList> observers,
-    SettingsStorage* storage) {
+bool SetSettingsFunction::RunWithStorage(SettingsStorage* storage) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  DictionaryValue *input;
+  DictionaryValue* input;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &input));
-  return UseWriteResult(
-      observers, storage->Set(SettingsStorage::DEFAULTS, *input));
+  return UseWriteResult(storage->Set(SettingsStorage::DEFAULTS, *input));
 }
 
 void SetSettingsFunction::GetQuotaLimitHeuristics(
     QuotaLimitHeuristics* heuristics) const {
   GetModificationQuotaLimitHeuristics(heuristics);
 }
 
-bool RemoveSettingsFunction::RunWithStorage(
-    scoped_refptr<SettingsObserverList> observers,
-    SettingsStorage* storage) {
+bool RemoveSettingsFunction::RunWithStorage(SettingsStorage* storage) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   Value *input;
   EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &input));
 
   switch (input->GetType()) {
     case Value::TYPE_STRING: {
       std::string as_string;
       input->GetAsString(&as_string);
-      return UseWriteResult(observers, storage->Remove(as_string));
+      return UseWriteResult(storage->Remove(as_string));
     }
 
     case Value::TYPE_LIST: {
       std::vector<std::string> as_string_list;
       AddAllStringValues(*static_cast<ListValue*>(input), &as_string_list);
-      return UseWriteResult(observers, storage->Remove(as_string_list));
+      return UseWriteResult(storage->Remove(as_string_list));
     }
 
     default:
       return UseWriteResult(
-          observers,
           SettingsStorage::WriteResult(kUnsupportedArgumentType));
   };
 }
 
 void RemoveSettingsFunction::GetQuotaLimitHeuristics(
     QuotaLimitHeuristics* heuristics) const {
   GetModificationQuotaLimitHeuristics(heuristics);
 }
 
-bool ClearSettingsFunction::RunWithStorage(
-    scoped_refptr<SettingsObserverList> observers,
-    SettingsStorage* storage) {
+bool ClearSettingsFunction::RunWithStorage(SettingsStorage* storage) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  return UseWriteResult(observers, storage->Clear());
+  return UseWriteResult(storage->Clear());
 }
 
 void ClearSettingsFunction::GetQuotaLimitHeuristics(
     QuotaLimitHeuristics* heuristics) const {
   GetModificationQuotaLimitHeuristics(heuristics);
 }
 
 }  // namespace extensions