Drive extension functions from ExtensionFunction::Run. The

extensions/browser/api/storage/storage_api.cc

 // Copyright 2014 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 "extensions/browser/api/storage/storage_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 14 matching lines @@
     : settings_namespace_(settings_namespace::INVALID),
       tried_restoring_storage_(false) {}
 
 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 should be EXTENSION_FUNCTION_VALIDATE(false) but there is no way
-    // to signify that from this function. It will be caught in
-    // RunImplTypesafe().
+    // to signify that from this function. It will be caught in Run().
     return false;
   }
   return settings_namespace_string != "sync";
 }
 
-ExtensionFunction::ResponseAction SettingsFunction::RunImplTypesafe() {
+ExtensionFunction::ResponseAction SettingsFunction::Run() {
   std::string settings_namespace_string;
   EXTENSION_FUNCTION_VALIDATE_TYPESAFE(
       args_->GetString(0, &settings_namespace_string));
   args_->Remove(0, NULL);
   settings_namespace_ =
       settings_namespace::FromString(settings_namespace_string);
   EXTENSION_FUNCTION_VALIDATE_TYPESAFE(settings_namespace_ !=
                                        settings_namespace::INVALID);
 
   StorageFrontend* frontend = StorageFrontend::Get(browser_context());
   if (!frontend->IsStorageEnabled(settings_namespace_)) {
     return RespondNow(Error(
         base::StringPrintf("\"%s\" is not available in this instance of Chrome",
                            settings_namespace_string.c_str())));
   }
 
   observers_ = frontend->GetObservers();
   frontend->RunWithStorage(
       GetExtension(),
       settings_namespace_,
       base::Bind(&SettingsFunction::AsyncRunWithStorage, this));
   return RespondLater();
 }
 
 void SettingsFunction::AsyncRunWithStorage(ValueStore* storage) {
   ResponseValue response = RunWithStorage(storage);
-  BrowserThread::PostTask(BrowserThread::UI,
-                          FROM_HERE,
-                          base::Bind(&SettingsFunction::SendResponseTypesafe,
-                                     this,
-                                     base::Passed(&response)));
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&SettingsFunction::Done, this, base::Passed(&response)));
 }
 
 ExtensionFunction::ResponseValue SettingsFunction::UseReadResult(
     ValueStore::ReadResult result,
     ValueStore* storage) {
   if (result->HasError())
     return HandleError(result->error(), storage);
 
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->Swap(&result->settings());
@@ skipping 219 matching lines @@
 StorageStorageAreaClearFunction::RunWithStorage(ValueStore* storage) {
   return UseWriteResult(storage->Clear(), storage);
 }
 
 void StorageStorageAreaClearFunction::GetQuotaLimitHeuristics(
     QuotaLimitHeuristics* heuristics) const {
   GetModificationQuotaLimitHeuristics(heuristics);
 }
 
 }  // namespace extensions