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

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/lazy_instance.h"
   6 #include "chrome/browser/browser_process.h"
   7 #include "chrome/browser/extensions/api/image_writer_private/destroy_partitions_operation.h"
   8 #include "chrome/browser/extensions/api/image_writer_private/error_messages.h"
   9 #include "chrome/browser/extensions/api/image_writer_private/operation.h"
  10 #include "chrome/browser/extensions/api/image_writer_private/operation_manager.h"
  11 #include "chrome/browser/extensions/api/image_writer_private/write_from_file_operation.h"
  12 #include "chrome/browser/extensions/api/image_writer_private/write_from_url_operation.h"
  13 #include "chrome/browser/extensions/event_router_forwarder.h"
  14 #include "chrome/browser/extensions/extension_service.h"
  15 #include "chrome/browser/profiles/profile.h"
  16 #include "content/public/browser/browser_thread.h"
  17 #include "content/public/browser/notification_service.h"
  18 #include "extensions/browser/event_router.h"
  19 #include "extensions/browser/extension_host.h"
  20 #include "extensions/browser/extension_registry.h"
  21 #include "extensions/browser/notification_types.h"
  22
  23 namespace image_writer_api = extensions::api::image_writer_private;
  24
  25 namespace extensions {
  26 namespace image_writer {
  27
  28 using content::BrowserThread;
  29
  30 OperationManager::OperationManager(content::BrowserContext* context)
  31     : browser_context_(context),
  32       extension_registry_observer_(this),
  33       weak_factory_(this) {
  34   extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context_));
  35   Profile* profile = Profile::FromBrowserContext(browser_context_);
  36   registrar_.Add(this,
  37                  extensions::NOTIFICATION_EXTENSION_PROCESS_TERMINATED,
  38                  content::Source<Profile>(profile));
  39   registrar_.Add(this,
  40                  extensions::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE,
  41                  content::Source<Profile>(profile));
  42   registrar_.Add(this,
  43                  extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
  44                  content::Source<Profile>(profile));
  45 }
  46
  47 OperationManager::~OperationManager() {
  48 }
  49
  50 void OperationManager::Shutdown() {
  51   for (OperationMap::iterator iter = operations_.begin();
  52        iter != operations_.end();
  53        iter++) {
  54     BrowserThread::PostTask(BrowserThread::FILE,
  55                             FROM_HERE,
  56                             base::Bind(&Operation::Abort,
  57                                        iter->second));
  58   }
  59 }
  60
  61 void OperationManager::StartWriteFromUrl(
  62     const ExtensionId& extension_id,
  63     GURL url,
  64     const std::string& hash,
  65     const std::string& device_path,
  66     const Operation::StartWriteCallback& callback) {
  67 #if defined(OS_CHROMEOS)
  68   // Chrome OS can only support a single operation at a time.
  69   if (operations_.size() > 0) {
  70 #else
  71   OperationMap::iterator existing_operation = operations_.find(extension_id);
  72
  73   if (existing_operation != operations_.end()) {
  74 #endif
  75     return callback.Run(false, error::kOperationAlreadyInProgress);
  76   }
  77
  78   scoped_refptr<Operation> operation(
  79       new WriteFromUrlOperation(weak_factory_.GetWeakPtr(),
  80                                 extension_id,
  81                                 browser_context_->GetRequestContext(),
  82                                 url,
  83                                 hash,
  84                                 device_path));
  85   operations_[extension_id] = operation;
  86   BrowserThread::PostTask(BrowserThread::FILE,
  87                           FROM_HERE,
  88                           base::Bind(&Operation::Start, operation));
  89   callback.Run(true, "");
  90 }
  91
  92 void OperationManager::StartWriteFromFile(
  93     const ExtensionId& extension_id,
  94     const base::FilePath& path,
  95     const std::string& device_path,
  96     const Operation::StartWriteCallback& callback) {
  97 #if defined(OS_CHROMEOS)
  98   // Chrome OS can only support a single operation at a time.
  99   if (operations_.size() > 0) {
 100 #else
 101   OperationMap::iterator existing_operation = operations_.find(extension_id);
 102
 103   if (existing_operation != operations_.end()) {
 104 #endif
 105     return callback.Run(false, error::kOperationAlreadyInProgress);
 106   }
 107
 108   scoped_refptr<Operation> operation(new WriteFromFileOperation(
 109       weak_factory_.GetWeakPtr(), extension_id, path, device_path));
 110   operations_[extension_id] = operation;
 111   BrowserThread::PostTask(BrowserThread::FILE,
 112                           FROM_HERE,
 113                           base::Bind(&Operation::Start, operation));
 114   callback.Run(true, "");
 115 }
 116
 117 void OperationManager::CancelWrite(
 118     const ExtensionId& extension_id,
 119     const Operation::CancelWriteCallback& callback) {
 120   Operation* existing_operation = GetOperation(extension_id);
 121
 122   if (existing_operation == NULL) {
 123     callback.Run(false, error::kNoOperationInProgress);
 124   } else {
 125     BrowserThread::PostTask(BrowserThread::FILE,
 126                             FROM_HERE,
 127                             base::Bind(&Operation::Cancel, existing_operation));
 128     DeleteOperation(extension_id);
 129     callback.Run(true, "");
 130   }
 131 }
 132
 133 void OperationManager::DestroyPartitions(
 134     const ExtensionId& extension_id,
 135     const std::string& device_path,
 136     const Operation::StartWriteCallback& callback) {
 137   OperationMap::iterator existing_operation = operations_.find(extension_id);
 138
 139   if (existing_operation != operations_.end()) {
 140     return callback.Run(false, error::kOperationAlreadyInProgress);
 141   }
 142
 143   scoped_refptr<Operation> operation(new DestroyPartitionsOperation(
 144       weak_factory_.GetWeakPtr(), extension_id, device_path));
 145   operations_[extension_id] = operation;
 146   BrowserThread::PostTask(BrowserThread::FILE,
 147                           FROM_HERE,
 148                           base::Bind(&Operation::Start, operation));
 149   callback.Run(true, "");
 150 }
 151
 152 void OperationManager::OnProgress(const ExtensionId& extension_id,
 153                                   image_writer_api::Stage stage,
 154                                   int progress) {
 155   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 156
 157   image_writer_api::ProgressInfo info;
 158   info.stage = stage;
 159   info.percent_complete = progress;
 160
 161   scoped_ptr<base::ListValue> args(
 162       image_writer_api::OnWriteProgress::Create(info));
 163   scoped_ptr<Event> event(new Event(
 164       image_writer_api::OnWriteProgress::kEventName, args.Pass()));
 165
 166   EventRouter::Get(browser_context_)
 167       ->DispatchEventToExtension(extension_id, event.Pass());
 168 }
 169
 170 void OperationManager::OnComplete(const ExtensionId& extension_id) {
 171   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 172
 173   scoped_ptr<base::ListValue> args(image_writer_api::OnWriteComplete::Create());
 174   scoped_ptr<Event> event(new Event(
 175       image_writer_api::OnWriteComplete::kEventName, args.Pass()));
 176
 177   EventRouter::Get(browser_context_)
 178       ->DispatchEventToExtension(extension_id, event.Pass());
 179
 180   DeleteOperation(extension_id);
 181 }
 182
 183 void OperationManager::OnError(const ExtensionId& extension_id,
 184                                image_writer_api::Stage stage,
 185                                int progress,
 186                                const std::string& error_message) {
 187   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 188   image_writer_api::ProgressInfo info;
 189
 190   DLOG(ERROR) << "ImageWriter error: " << error_message;
 191
 192   info.stage = stage;
 193   info.percent_complete = progress;
 194
 195   scoped_ptr<base::ListValue> args(
 196       image_writer_api::OnWriteError::Create(info, error_message));
 197   scoped_ptr<Event> event(new Event(
 198       image_writer_api::OnWriteError::kEventName, args.Pass()));
 199
 200   EventRouter::Get(browser_context_)
 201       ->DispatchEventToExtension(extension_id, event.Pass());
 202
 203   DeleteOperation(extension_id);
 204 }
 205
 206 Operation* OperationManager::GetOperation(const ExtensionId& extension_id) {
 207   OperationMap::iterator existing_operation = operations_.find(extension_id);
 208
 209   if (existing_operation == operations_.end())
 210     return NULL;
 211   return existing_operation->second.get();
 212 }
 213
 214 void OperationManager::DeleteOperation(const ExtensionId& extension_id) {
 215   OperationMap::iterator existing_operation = operations_.find(extension_id);
 216   if (existing_operation != operations_.end()) {
 217     operations_.erase(existing_operation);
 218   }
 219 }
 220
 221 void OperationManager::OnExtensionUnloaded(
 222     content::BrowserContext* browser_context,
 223     const Extension* extension,
 224     UnloadedExtensionInfo::Reason reason) {
 225   DeleteOperation(extension->id());
 226 }
 227
 228 void OperationManager::Observe(int type,
 229                                const content::NotificationSource& source,
 230                                const content::NotificationDetails& details) {
 231   switch (type) {
 232     case extensions::NOTIFICATION_EXTENSION_PROCESS_TERMINATED: {
 233       DeleteOperation(content::Details<const Extension>(details).ptr()->id());
 234       break;
 235     }
 236     case extensions::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE: {
 237       DeleteOperation(
 238         content::Details<ExtensionHost>(details)->extension()->id());
 239       break;
 240     }
 241     case extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED: {
 242       DeleteOperation(
 243         content::Details<ExtensionHost>(details)->extension()->id());
 244       break;
 245     }
 246     default: {
 247       NOTREACHED();
 248       break;
 249     }
 250   }
 251 }
 252
 253 OperationManager* OperationManager::Get(content::BrowserContext* context) {
 254   return BrowserContextKeyedAPIFactory<OperationManager>::Get(context);
 255 }
 256
 257 static base::LazyInstance<BrowserContextKeyedAPIFactory<OperationManager> >
 258     g_factory = LAZY_INSTANCE_INITIALIZER;
 259
 260 BrowserContextKeyedAPIFactory<OperationManager>*
 261 OperationManager::GetFactoryInstance() {
 262   return g_factory.Pointer();
 263 }
 264
 265
 266 }  // namespace image_writer
 267 }  // namespace extensions