Drive extension functions from ExtensionFunction::Run. The

chrome/browser/extensions/api/alarms/alarms_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/alarms/alarms_api.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/time/clock.h"
 #include "base/time/default_clock.h"
 #include "base/values.h"
@@ skipping 80 matching lines @@
     : clock_(new base::DefaultClock()), owns_clock_(true) {}
 
 AlarmsCreateFunction::AlarmsCreateFunction(base::Clock* clock)
     : clock_(clock), owns_clock_(false) {}
 
 AlarmsCreateFunction::~AlarmsCreateFunction() {
   if (owns_clock_)
     delete clock_;
 }
 
-bool AlarmsCreateFunction::RunImpl() {
+bool AlarmsCreateFunction::RunAsync() {
   scoped_ptr<alarms::Create::Params> params(
       alarms::Create::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   const std::string& alarm_name =
       params->name.get() ? *params->name : kDefaultAlarmName;
   std::vector<std::string> warnings;
   if (!ValidateAlarmCreateInfo(
           alarm_name, params->alarm_info, GetExtension(), &error_, &warnings)) {
     return false;
   }
@@ skipping 10 matching lines @@
   AlarmManager::Get(GetProfile())->AddAlarm(
       extension_id(), alarm, base::Bind(&AlarmsCreateFunction::Callback, this));
 
   return true;
 }
 
 void AlarmsCreateFunction::Callback() {
   SendResponse(true);
 }
 
-bool AlarmsGetFunction::RunImpl() {
+bool AlarmsGetFunction::RunAsync() {
   scoped_ptr<alarms::Get::Params> params(alarms::Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::string name = params->name.get() ? *params->name : kDefaultAlarmName;
   AlarmManager::Get(GetProfile())
       ->GetAlarm(extension_id(),
                  name,
                  base::Bind(&AlarmsGetFunction::Callback, this, name));
 
   return true;
 }
 
 void AlarmsGetFunction::Callback(
     const std::string& name, extensions::Alarm* alarm) {
   if (alarm) {
     results_ = alarms::Get::Results::Create(*alarm->js_alarm);
   }
   SendResponse(true);
 }
 
-bool AlarmsGetAllFunction::RunImpl() {
+bool AlarmsGetAllFunction::RunAsync() {
   AlarmManager::Get(GetProfile())->GetAllAlarms(
       extension_id(), base::Bind(&AlarmsGetAllFunction::Callback, this));
   return true;
 }
 
 void AlarmsGetAllFunction::Callback(const AlarmList* alarms) {
   if (alarms) {
     std::vector<linked_ptr<extensions::api::alarms::Alarm> > create_arg;
     create_arg.reserve(alarms->size());
     for (size_t i = 0, size = alarms->size(); i < size; ++i) {
       create_arg.push_back((*alarms)[i].js_alarm);
     }
     results_ = alarms::GetAll::Results::Create(create_arg);
   } else {
     SetResult(new base::ListValue());
   }
   SendResponse(true);
 }
 
-bool AlarmsClearFunction::RunImpl() {
+bool AlarmsClearFunction::RunAsync() {
   scoped_ptr<alarms::Clear::Params> params(
       alarms::Clear::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::string name = params->name.get() ? *params->name : kDefaultAlarmName;
   AlarmManager::Get(GetProfile())
       ->RemoveAlarm(extension_id(),
                     name,
                     base::Bind(&AlarmsClearFunction::Callback, this, name));
 
   return true;
 }
 
 void AlarmsClearFunction::Callback(const std::string& name, bool success) {
   SetResult(new base::FundamentalValue(success));
   SendResponse(true);
 }
 
-bool AlarmsClearAllFunction::RunImpl() {
+bool AlarmsClearAllFunction::RunAsync() {
   AlarmManager::Get(GetProfile())->RemoveAllAlarms(
       extension_id(), base::Bind(&AlarmsClearAllFunction::Callback, this));
   return true;
 }
 
 void AlarmsClearAllFunction::Callback() {
   SetResult(new base::FundamentalValue(true));
   SendResponse(true);
 }
 
 }  // namespace extensions