Drive extension functions from ExtensionFunction::Run. The

chrome/browser/extensions/api/image_writer_private/image_writer_private_api.cc

 // Copyright 2013 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 "base/logging.h"
 #include "chrome/browser/extensions/api/file_handlers/app_file_handler_util.h"
 #include "chrome/browser/extensions/api/image_writer_private/error_messages.h"
 #include "chrome/browser/extensions/api/image_writer_private/image_writer_private_api.h"
 #include "chrome/browser/extensions/api/image_writer_private/operation_manager.h"
 #include "chrome/browser/profiles/profile.h"
 
 namespace image_writer_api = extensions::api::image_writer_private;
 
 namespace extensions {
 
 ImageWriterPrivateWriteFromUrlFunction::
     ImageWriterPrivateWriteFromUrlFunction() {
 }
 
 ImageWriterPrivateWriteFromUrlFunction::
     ~ImageWriterPrivateWriteFromUrlFunction() {
 }
 
-bool ImageWriterPrivateWriteFromUrlFunction::RunImpl() {
+bool ImageWriterPrivateWriteFromUrlFunction::RunAsync() {
   scoped_ptr<image_writer_api::WriteFromUrl::Params> params(
       image_writer_api::WriteFromUrl::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   GURL url(params->image_url);
   if (!url.is_valid()) {
     error_ = image_writer::error::kUrlInvalid;
     return false;
   }
 
@@ skipping 23 matching lines @@
 }
 
 ImageWriterPrivateWriteFromFileFunction::
     ImageWriterPrivateWriteFromFileFunction() {
 }
 
 ImageWriterPrivateWriteFromFileFunction::
     ~ImageWriterPrivateWriteFromFileFunction() {
 }
 
-bool ImageWriterPrivateWriteFromFileFunction::RunImpl() {
+bool ImageWriterPrivateWriteFromFileFunction::RunAsync() {
   std::string filesystem_name;
   std::string filesystem_path;
   std::string storage_unit_id;
 
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &storage_unit_id));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &filesystem_name));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &filesystem_path));
 
   base::FilePath path;
 
@@ skipping 23 matching lines @@
   SendResponse(success);
 }
 
 ImageWriterPrivateCancelWriteFunction::ImageWriterPrivateCancelWriteFunction() {
 }
 
 ImageWriterPrivateCancelWriteFunction::
     ~ImageWriterPrivateCancelWriteFunction() {
 }
 
-bool ImageWriterPrivateCancelWriteFunction::RunImpl() {
+bool ImageWriterPrivateCancelWriteFunction::RunAsync() {
   image_writer::OperationManager::Get(GetProfile())->CancelWrite(
       extension_id(),
       base::Bind(&ImageWriterPrivateCancelWriteFunction::OnWriteCancelled,
                  this));
   return true;
 }
 
 void ImageWriterPrivateCancelWriteFunction::OnWriteCancelled(
     bool success,
     const std::string& error) {
   if (!success) {
     error_ = error;
   }
   SendResponse(success);
 }
 
 ImageWriterPrivateDestroyPartitionsFunction::
     ImageWriterPrivateDestroyPartitionsFunction() {
 }
 
 ImageWriterPrivateDestroyPartitionsFunction::
     ~ImageWriterPrivateDestroyPartitionsFunction() {
 }
 
-bool ImageWriterPrivateDestroyPartitionsFunction::RunImpl() {
+bool ImageWriterPrivateDestroyPartitionsFunction::RunAsync() {
   scoped_ptr<image_writer_api::DestroyPartitions::Params> params(
       image_writer_api::DestroyPartitions::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   image_writer::OperationManager::Get(GetProfile())->DestroyPartitions(
       extension_id(),
       params->storage_unit_id,
       base::Bind(
           &ImageWriterPrivateDestroyPartitionsFunction::OnDestroyComplete,
           this));
@@ skipping 11 matching lines @@
 }
 
 ImageWriterPrivateListRemovableStorageDevicesFunction::
   ImageWriterPrivateListRemovableStorageDevicesFunction() {
 }
 
 ImageWriterPrivateListRemovableStorageDevicesFunction::
   ~ImageWriterPrivateListRemovableStorageDevicesFunction() {
 }
 
-bool ImageWriterPrivateListRemovableStorageDevicesFunction::RunImpl() {
+bool ImageWriterPrivateListRemovableStorageDevicesFunction::RunAsync() {
   RemovableStorageProvider::GetAllDevices(
     base::Bind(
       &ImageWriterPrivateListRemovableStorageDevicesFunction::OnDeviceListReady,
       this));
   return true;
 }
 
 void ImageWriterPrivateListRemovableStorageDevicesFunction::OnDeviceListReady(
     scoped_refptr<StorageDeviceList> device_list,
     bool success) {
   if (success) {
     results_ =
       image_writer_api::ListRemovableStorageDevices::Results::Create(
         device_list.get()->data);
     SendResponse(true);
   } else {
     error_ = image_writer::error::kDeviceListError;
     SendResponse(false);
   }
 }
 
 }  // namespace extensions