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(
 164       new Event(events::IMAGE_WRITER_PRIVATE_ON_WRITE_PROGRESS,
 165                 image_writer_api::OnWriteProgress::kEventName, args.Pass()));
 166
 167   EventRouter::Get(browser_context_)
 168       ->DispatchEventToExtension(extension_id, event.Pass());
 169 }
 170
 171 void OperationManager::OnComplete(const ExtensionId& extension_id) {
 172   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 173
 174   scoped_ptr<base::ListValue> args(image_writer_api::OnWriteComplete::Create());
 175   scoped_ptr<Event> event(
 176       new Event(events::IMAGE_WRITER_PRIVATE_ON_WRITE_COMPLETE,
 177                 image_writer_api::OnWriteComplete::kEventName, args.Pass()));
 178
 179   EventRouter::Get(browser_context_)
 180       ->DispatchEventToExtension(extension_id, event.Pass());
 181
 182   DeleteOperation(extension_id);
 183 }
 184
 185 void OperationManager::OnError(const ExtensionId& extension_id,
 186                                image_writer_api::Stage stage,
 187                                int progress,
 188                                const std::string& error_message) {
 189   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 190   image_writer_api::ProgressInfo info;
 191
 192   DLOG(ERROR) << "ImageWriter error: " << error_message;
 193
 194   info.stage = stage;
 195   info.percent_complete = progress;
 196
 197   scoped_ptr<base::ListValue> args(
 198       image_writer_api::OnWriteError::Create(info, error_message));
 199   scoped_ptr<Event> event(new Event(events::IMAGE_WRITER_PRIVATE_ON_WRITE_ERROR,
 200                                     image_writer_api::OnWriteError::kEventName,
 201                                     args.Pass()));
 202
 203   EventRouter::Get(browser_context_)
 204       ->DispatchEventToExtension(extension_id, event.Pass());
 205
 206   DeleteOperation(extension_id);
 207 }
 208
 209 Operation* OperationManager::GetOperation(const ExtensionId& extension_id) {
 210   OperationMap::iterator existing_operation = operations_.find(extension_id);
 211
 212   if (existing_operation == operations_.end())
 213     return NULL;
 214   return existing_operation->second.get();
 215 }
 216
 217 void OperationManager::DeleteOperation(const ExtensionId& extension_id) {
 218   OperationMap::iterator existing_operation = operations_.find(extension_id);
 219   if (existing_operation != operations_.end()) {
 220     operations_.erase(existing_operation);
 221   }
 222 }
 223
 224 void OperationManager::OnExtensionUnloaded(
 225     content::BrowserContext* browser_context,
 226     const Extension* extension,
 227     UnloadedExtensionInfo::Reason reason) {
 228   DeleteOperation(extension->id());
 229 }
 230
 231 void OperationManager::Observe(int type,
 232                                const content::NotificationSource& source,
 233                                const content::NotificationDetails& details) {
 234   switch (type) {
 235     case extensions::NOTIFICATION_EXTENSION_PROCESS_TERMINATED: {
 236       DeleteOperation(content::Details<const Extension>(details).ptr()->id());
 237       break;
 238     }
 239     case extensions::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE: {
 240       DeleteOperation(
 241         content::Details<ExtensionHost>(details)->extension()->id());
 242       break;
 243     }
 244     case extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED: {
 245       DeleteOperation(
 246         content::Details<ExtensionHost>(details)->extension()->id());
 247       break;
 248     }
 249     default: {
 250       NOTREACHED();
 251       break;
 252     }
 253   }
 254 }
 255
 256 OperationManager* OperationManager::Get(content::BrowserContext* context) {
 257   return BrowserContextKeyedAPIFactory<OperationManager>::Get(context);
 258 }
 259
 260 static base::LazyInstance<BrowserContextKeyedAPIFactory<OperationManager> >
 261     g_factory = LAZY_INSTANCE_INITIALIZER;
 262
 263 BrowserContextKeyedAPIFactory<OperationManager>*
 264 OperationManager::GetFactoryInstance() {
 265   return g_factory.Pointer();
 266 }
 267
 268
 269 }  // namespace image_writer
 270 }  // namespace extensions