Implement startCopy and cancelCopy.

chrome/browser/chromeos/extensions/file_manager/event_router.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/chromeos/extensions/file_manager/event_router.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_change_registrar.h"
@@ skipping 13 matching lines @@
 #include "chrome/browser/chromeos/file_manager/open_util.h"
 #include "chrome/browser/chromeos/file_manager/volume_manager.h"
 #include "chrome/browser/chromeos/login/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/screen_locker.h"
 #include "chrome/browser/drive/drive_service_interface.h"
 #include "chrome/browser/extensions/event_names.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/common/extensions/api/file_browser_private.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/login/login_state.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_source.h"
 #include "webkit/common/fileapi/file_system_types.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 using chromeos::disks::DiskMountManager;
@@ skipping 176 matching lines @@
       return util::VolumeTypeToStringEnum(VOLUME_TYPE_REMOVABLE_DISK_PARTITION);
     case chromeos::MOUNT_TYPE_ARCHIVE:
       return util::VolumeTypeToStringEnum(VOLUME_TYPE_MOUNTED_ARCHIVE_FILE);
     case chromeos::MOUNT_TYPE_GOOGLE_DRIVE:
       return util::VolumeTypeToStringEnum(VOLUME_TYPE_GOOGLE_DRIVE);
   }
   NOTREACHED();
   return "";
 }
 
+// Sends an event named |event_name| with arguments |event_args| to extensions.
+void BroadcastEvent(Profile* profile,
+                    const std::string& event_name,
+                    scoped_ptr<base::ListValue> event_args) {
+  extensions::ExtensionSystem::Get(profile)->event_router()->
+      BroadcastEvent(make_scoped_ptr(
+          new extensions::Event(event_name, event_args.Pass())));
+}
+
 }  // namespace
 
 // Pass dummy value to JobInfo's constructor for make it default constructible.
 EventRouter::DriveJobInfoWithStatus::DriveJobInfoWithStatus()
     : job_info(drive::TYPE_DOWNLOAD_FILE) {
 }
 
 EventRouter::DriveJobInfoWithStatus::DriveJobInfoWithStatus(
     const drive::JobInfo& info, const std::string& status)
     : job_info(info), status(status) {
 }
 
-EventRouter::EventRouter(
-    Profile* profile)
+EventRouter::EventRouter(Profile* profile)
     : notifications_(new DesktopNotifications(profile)),
       pref_change_registrar_(new PrefChangeRegistrar),
       profile_(profile),
       weak_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 EventRouter::~EventRouter() {
 }
 
@@ skipping 145 matching lines @@
   if (iter == file_watchers_.end())
     return;
   // Remove the watcher if |watch_path| is no longer watched by any extensions.
   iter->second->RemoveExtension(extension_id);
   if (iter->second->GetExtensionIds().empty()) {
     delete iter->second;
     file_watchers_.erase(iter);
   }
 }
 
+void EventRouter::OnCopyCompleted(
+    int copy_id, const GURL& url, base::PlatformFileError error) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  using extensions::api::file_browser_private::CopyProgressStatus;
+  namespace OnCopyProgress =
+      extensions::api::file_browser_private::OnCopyProgress;
+
+  CopyProgressStatus status;
+  if (error == base::PLATFORM_FILE_OK) {
+    // Send success event.
+    status.type = CopyProgressStatus::TYPE_SUCCESS;
+    status.url.reset(new std::string(url.spec()));
+  } else {
+    // Send error event.
+    status.type = CopyProgressStatus::TYPE_ERROR;
+    status.error.reset(
+        new int(fileapi::PlatformFileErrorToWebFileError(error)));
+  }
+
+  BroadcastEvent(
+      profile_,
+      extensions::event_names::kOnFileBrowserCopyProgress,
+      OnCopyProgress::Create(copy_id, status));
+}
+
 void EventRouter::OnDiskEvent(DiskMountManager::DiskEvent event,
                               const DiskMountManager::Disk* disk) {
   // Disk event is dispatched by VolumeManager now. Do nothing.
 }
 
 void EventRouter::OnDeviceEvent(DiskMountManager::DeviceEvent event,
                                 const std::string& device_path) {
   // Device event is dispatched by VolumeManager now. Do nothing.
 }
 
@@ skipping 53 matching lines @@
                                 const std::string& device_path) {
   // Format event is dispatched by VolumeManager now. Do nothing.
 }
 
 void EventRouter::NetworkManagerChanged() {
   if (!profile_ ||
       !extensions::ExtensionSystem::Get(profile_)->event_router()) {
     NOTREACHED();
     return;
   }
-  scoped_ptr<extensions::Event> event(new extensions::Event(
+
+  BroadcastEvent(
+      profile_,
       extensions::event_names::kOnFileBrowserDriveConnectionStatusChanged,
-      scoped_ptr<ListValue>(new ListValue())));
-  extensions::ExtensionSystem::Get(profile_)->event_router()->
-      BroadcastEvent(event.Pass());
+      make_scoped_ptr(new ListValue));
 }
 
 void EventRouter::DefaultNetworkChanged(const chromeos::NetworkState* network) {
   NetworkManagerChanged();
 }
 
 void EventRouter::OnExternalStorageDisabledChanged() {
   // If the policy just got disabled we have to unmount every device currently
   // mounted. The opposite is fine - we can let the user re-plug her device to
   // make it available.
@@ skipping 11 matching lines @@
   }
 }
 
 void EventRouter::OnFileManagerPrefsChanged() {
   if (!profile_ ||
       !extensions::ExtensionSystem::Get(profile_)->event_router()) {
     NOTREACHED();
     return;
   }
 
-  scoped_ptr<extensions::Event> event(new extensions::Event(
+  BroadcastEvent(
+      profile_,
       extensions::event_names::kOnFileBrowserPreferencesChanged,
-      scoped_ptr<ListValue>(new ListValue())));
-  extensions::ExtensionSystem::Get(profile_)->event_router()->
-      BroadcastEvent(event.Pass());
+      make_scoped_ptr(new ListValue));
 }
 
 void EventRouter::OnJobAdded(const drive::JobInfo& job_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   OnJobUpdated(job_info);
 }
 
 void EventRouter::OnJobUpdated(const drive::JobInfo& job_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!drive::IsActiveFileTransferJobInfo(job_info))
@@ skipping 101 matching lines @@
       chromeos::MOUNT_TYPE_GOOGLE_DRIVE,
       chromeos::disks::MOUNT_CONDITION_NONE);
   OnMountEvent(DiskMountManager::UNMOUNTING, chromeos::MOUNT_ERROR_NONE,
                mount_info);
 }
 
 void EventRouter::OnRefreshTokenInvalid() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Raise a DriveConnectionStatusChanged event to notify the status offline.
-  scoped_ptr<extensions::Event> event(new extensions::Event(
+  BroadcastEvent(
+      profile_,
       extensions::event_names::kOnFileBrowserDriveConnectionStatusChanged,
-      scoped_ptr<ListValue>(new ListValue())));
-  extensions::ExtensionSystem::Get(profile_)->event_router()->
-      BroadcastEvent(event.Pass());
+      make_scoped_ptr(new ListValue));
 }
 
 void EventRouter::HandleFileWatchNotification(const base::FilePath& local_path,
                                               bool got_error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   WatcherMap::const_iterator iter = file_watchers_.find(local_path);
   if (iter == file_watchers_.end()) {
     return;
   }
@@ skipping 70 matching lines @@
             &relative_mount_path)) {
       mount_info_value->SetString("mountPath",
                                   "/" + relative_mount_path.value());
     } else {
       mount_info_value->SetString(
           "status",
           MountErrorToString(chromeos::MOUNT_ERROR_PATH_UNMOUNTED));
     }
   }
 
-  scoped_ptr<extensions::Event> extension_event(new extensions::Event(
-      extensions::event_names::kOnFileBrowserMountCompleted, args.Pass()));
-  extensions::ExtensionSystem::Get(profile_)->event_router()->
-      BroadcastEvent(extension_event.Pass());
+  BroadcastEvent(profile_,
+                 extensions::event_names::kOnFileBrowserMountCompleted,
+                 args.Pass());
 }
 
 void EventRouter::ShowRemovableDeviceInFileManager(
     const DiskMountManager::Disk& disk,
     const base::FilePath& mount_path) {
   // Do not attempt to open File Manager while the login is in progress or
   // the screen is locked.
   if (chromeos::LoginDisplayHostImpl::default_host() ||
       chromeos::ScreenLocker::default_screen_locker())
     return;
@@ skipping 87 matching lines @@
         base::TimeDelta::FromSeconds(4));
   } else {
     notifications_->HideNotification(DesktopNotifications::FORMAT_START,
                                      device_path);
     notifications_->ShowNotification(DesktopNotifications::FORMAT_FAIL,
                                      device_path);
   }
 }
 
 }  // namespace file_manager