Files.app: Use types and constants generated by the IDL compiler in the event router.

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 32 matching lines @@
 using chromeos::NetworkHandler;
 using content::BrowserThread;
 using drive::DriveIntegrationService;
 using drive::DriveIntegrationServiceFactory;
 
 namespace file_browser_private = extensions::api::file_browser_private;
 
 namespace file_manager {
 namespace {
 
-const char kPathChanged[] = "changed";
-const char kPathWatchError[] = "error";
-
 void DirectoryExistsOnBlockingPool(const base::FilePath& directory_path,
                                    const base::Closure& success_callback,
                                    const base::Closure& failure_callback) {
   DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 
   if (base::DirectoryExists(directory_path))
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, success_callback);
   else
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, failure_callback);
 };
@@ skipping 19 matching lines @@
 
 // Frequency of sending onFileTransferUpdated.
 const int64 kFileTransferEventFrequencyInMilliseconds = 1000;
 
 // Utility function to check if |job_info| is a file uploading job.
 bool IsUploadJob(drive::JobType type) {
   return (type == drive::TYPE_UPLOAD_NEW_FILE ||
           type == drive::TYPE_UPLOAD_EXISTING_FILE);
 }
 
-// Converts the job info to its JSON (Value) form.
-scoped_ptr<base::DictionaryValue> JobInfoToDictionaryValue(
+// Converts the job info to a IDL generated type.
+void JobInfoToTransferStatus(
     const std::string& extension_id,
     const std::string& job_status,
-    const drive::JobInfo& job_info) {
+    const drive::JobInfo& job_info,
+    file_browser_private::FileTransferStatus* status) {
   DCHECK(IsActiveFileTransferJobInfo(job_info));
 
   scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue);
   GURL url = util::ConvertRelativeFilePathToFileSystemUrl(
       job_info.file_path, extension_id);
-  result->SetString("fileUrl", url.spec());
-  result->SetString("transferState", job_status);
-  result->SetString("transferType",
-                    IsUploadJob(job_info.job_type) ? "upload" : "download");
+  status->file_url = url.spec();
+  status->transfer_state = file_browser_private::ParseTransferState(job_status);
+  status->transfer_type =
+      IsUploadJob(job_info.job_type) ?
+      file_browser_private::TRANSFER_TYPE_UPLOAD :
+      file_browser_private::TRANSFER_TYPE_DOWNLOAD;
   // JavaScript does not have 64-bit integers. Instead we use double, which
   // is in IEEE 754 formant and accurate up to 52-bits in JS, and in practice
   // in C++. Larger values are rounded.
-  result->SetDouble("processed",
-                    static_cast<double>(job_info.num_completed_bytes));
-  result->SetDouble("total", static_cast<double>(job_info.num_total_bytes));
-  return result.Pass();
+  status->processed.reset(
+      new double(static_cast<double>(job_info.num_completed_bytes)));
+  status->total.reset(
+      new double(static_cast<double>(job_info.num_total_bytes)));
 }
 
 // Checks for availability of the Google+ Photos app.
 bool IsGooglePhotosInstalled(Profile *profile) {
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   if (!service)
     return false;
 
   // Google+ Photos uses several ids for different channels. Therefore, all of
@@ skipping 92 matching lines @@
       profile, volume_info, &event.volume_metadata);
 
   if (!volume_info.mount_path.empty() &&
       event.volume_metadata.mount_path.empty()) {
     event.status =
         file_browser_private::MOUNT_COMPLETED_STATUS_ERROR_PATH_UNMOUNTED;
   }
 
   BroadcastEvent(
       profile,
-      extensions::event_names::kOnFileBrowserMountCompleted,
+      file_browser_private::OnMountCompleted::kEventName,
       file_browser_private::OnMountCompleted::Create(event));
 }
 
 file_browser_private::CopyProgressStatusType
 CopyProgressTypeToCopyProgressStatusType(
     fileapi::FileSystemOperation::CopyProgressType type) {
   switch (type) {
     case fileapi::FileSystemOperation::BEGIN_COPY_ENTRY:
       return file_browser_private::COPY_PROGRESS_STATUS_TYPE_BEGIN_COPY_ENTRY;
     case fileapi::FileSystemOperation::END_COPY_ENTRY:
@@ skipping 182 matching lines @@
     status.destination_url.reset(new std::string(destination_url.spec()));
   } else {
     // Send error event.
     status.type = file_browser_private::COPY_PROGRESS_STATUS_TYPE_ERROR;
     status.error.reset(
         new int(fileapi::PlatformFileErrorToWebFileError(error)));
   }
 
   BroadcastEvent(
       profile_,
-      extensions::event_names::kOnFileBrowserCopyProgress,
+      file_browser_private::OnCopyProgress::kEventName,
       file_browser_private::OnCopyProgress::Create(copy_id, status));
 }
 
 void EventRouter::OnCopyProgress(
     int copy_id,
     fileapi::FileSystemOperation::CopyProgressType type,
     const GURL& source_url,
     const GURL& destination_url,
     int64 size) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   file_browser_private::CopyProgressStatus status;
   status.type = CopyProgressTypeToCopyProgressStatusType(type);
   status.source_url.reset(new std::string(source_url.spec()));
   if (type == fileapi::FileSystemOperation::END_COPY_ENTRY)
     status.destination_url.reset(new std::string(destination_url.spec()));
   if (type == fileapi::FileSystemOperation::PROGRESS)
     status.size.reset(new double(size));
 
   BroadcastEvent(
       profile_,
-      extensions::event_names::kOnFileBrowserCopyProgress,
+      file_browser_private::OnCopyProgress::kEventName,
       file_browser_private::OnCopyProgress::Create(copy_id, status));
 }
 
 void EventRouter::DefaultNetworkChanged(const chromeos::NetworkState* network) {
   if (!profile_ ||
       !extensions::ExtensionSystem::Get(profile_)->event_router()) {
     NOTREACHED();
     return;
   }
 
   BroadcastEvent(
       profile_,
-      extensions::event_names::kOnFileBrowserDriveConnectionStatusChanged,
-      make_scoped_ptr(new base::ListValue));
+      file_browser_private::OnDriveConnectionStatusChanged::kEventName,
+      file_browser_private::OnDriveConnectionStatusChanged::Create());
 }
 
 void EventRouter::OnFileManagerPrefsChanged() {
   if (!profile_ ||
       !extensions::ExtensionSystem::Get(profile_)->event_router()) {
     NOTREACHED();
     return;
   }
 
   BroadcastEvent(
       profile_,
-      extensions::event_names::kOnFileBrowserPreferencesChanged,
-      make_scoped_ptr(new base::ListValue));
+      file_browser_private::OnPreferencesChanged::kEventName,
+      file_browser_private::OnPreferencesChanged::Create());
 }
 
 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 40 matching lines @@
   // amount of time passes after the previous one. This is to avoid
   // flooding the IPC between extensions by many onFileTransferUpdated events.
   if (!always) {
     const int64 delta = (now - last_file_transfer_event_).InMilliseconds();
     // delta < 0 may rarely happen if system clock is synced and rewinded.
     // To be conservative, we don't skip in that case.
     if (0 <= delta && delta < kFileTransferEventFrequencyInMilliseconds)
       return;
   }
 
-  // Convert the current |drive_jobs_| to a JSON value.
-  scoped_ptr<base::ListValue> event_list(new base::ListValue);
+  // Convert the current |drive_jobs_| to IDL type.
+  std::vector<linked_ptr<file_browser_private::FileTransferStatus> >
+      status_list;
   for (std::map<drive::JobID, DriveJobInfoWithStatus>::iterator
            iter = drive_jobs_.begin(); iter != drive_jobs_.end(); ++iter) {
-
-    scoped_ptr<base::DictionaryValue> job_info_dict(
-        JobInfoToDictionaryValue(kFileManagerAppId,
-                                 iter->second.status,
-                                 iter->second.job_info));
-    event_list->Append(job_info_dict.release());
+    linked_ptr<file_browser_private::FileTransferStatus> status(
+        new file_browser_private::FileTransferStatus());
+    JobInfoToTransferStatus(kFileManagerAppId,
+                            iter->second.status,
+                            iter->second.job_info,
+                            status.get());
+    status_list.push_back(status);
   }
-
-  scoped_ptr<base::ListValue> args(new base::ListValue());
-  args->Append(event_list.release());
-  scoped_ptr<extensions::Event> event(new extensions::Event(
-      extensions::event_names::kOnFileTransfersUpdated, args.Pass()));
-  extensions::ExtensionSystem::Get(profile_)->event_router()->
-      DispatchEventToExtension(kFileManagerAppId, event.Pass());
-
+  BroadcastEvent(
+      profile_,
+      file_browser_private::OnFileTransfersUpdated::kEventName,
+      file_browser_private::OnFileTransfersUpdated::Create(status_list));
   last_file_transfer_event_ = now;
 }
 
 void EventRouter::OnDirectoryChanged(const base::FilePath& directory_path) {
   HandleFileWatchNotification(directory_path, false);
 }
 
 void EventRouter::OnRefreshTokenInvalid() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Raise a DriveConnectionStatusChanged event to notify the status offline.
   BroadcastEvent(
       profile_,
-      extensions::event_names::kOnFileBrowserDriveConnectionStatusChanged,
-      make_scoped_ptr(new base::ListValue));
+      file_browser_private::OnDriveConnectionStatusChanged::kEventName,
+      file_browser_private::OnDriveConnectionStatusChanged::Create());
 }
 
 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;
   }
   DispatchDirectoryChangeEvent(iter->second->virtual_path(), got_error,
                                iter->second->GetExtensionIds());
 }
 
 void EventRouter::DispatchDirectoryChangeEvent(
     const base::FilePath& virtual_path,
     bool got_error,
     const std::vector<std::string>& extension_ids) {
   if (!profile_) {
     NOTREACHED();
     return;
   }
 
   for (size_t i = 0; i < extension_ids.size(); ++i) {
     const std::string& extension_id = extension_ids[i];
+    const GURL target_origin_url(
+        extensions::Extension::GetBaseURLFromExtensionId(extension_id));
+    // This will be replaced with a real Entry in custom bindings.
+    const fileapi::FileSystemInfo info =
+        fileapi::GetFileSystemInfoForChromeOS(target_origin_url.GetOrigin());
 
-    GURL target_origin_url(extensions::Extension::GetBaseURLFromExtensionId(
-        extension_id));
-    scoped_ptr<base::ListValue> args(new base::ListValue());
-    base::DictionaryValue* watch_info = new base::DictionaryValue();
-    args->Append(watch_info);
+    file_browser_private::FileWatchEvent event;
+    event.event_type = got_error ?
+        file_browser_private::FILE_WATCH_EVENT_TYPE_ERROR :
+        file_browser_private::FILE_WATCH_EVENT_TYPE_CHANGED;
+    event.entry.additional_properties.SetString("fileSystemName", info.name);
+    event.entry.additional_properties.SetString("fileSystemRoot",
+                                                info.root_url.spec());
+    event.entry.additional_properties.SetString("fileFullPath",
+                                                "/" + virtual_path.value());
+    event.entry.additional_properties.SetBoolean("fileIsDirectory", true);
 
-    // This will be replaced with a real Entry in custom bindings.
-    fileapi::FileSystemInfo info =
-        fileapi::GetFileSystemInfoForChromeOS(target_origin_url.GetOrigin());
-    base::DictionaryValue* entry = new base::DictionaryValue();
-    entry->SetString("fileSystemName", info.name);
-    entry->SetString("fileSystemRoot", info.root_url.spec());
-    entry->SetString("fileFullPath", "/" + virtual_path.value());
-    entry->SetBoolean("fileIsDirectory", true);
-    watch_info->Set("entry", entry);
-    watch_info->SetString("eventType",
-                          got_error ? kPathWatchError : kPathChanged);
-    scoped_ptr<extensions::Event> event(new extensions::Event(
-        extensions::event_names::kOnDirectoryChanged, args.Pass()));
-    extensions::ExtensionSystem::Get(profile_)->event_router()->
-        DispatchEventToExtension(extension_id, event.Pass());
+    BroadcastEvent(
+        profile_,
+        file_browser_private::OnDirectoryChanged::kEventName,
+        file_browser_private::OnDirectoryChanged::Create(event));
   }
 }
 
 void EventRouter::ShowRemovableDeviceInFileManager(
     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 124 matching lines @@
 void EventRouter::OnFormatCompleted(const std::string& device_path,
                                     bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DispatchDeviceEvent(success ?
                       file_browser_private::DEVICE_EVENT_TYPE_FORMAT_SUCCESS :
                       file_browser_private::DEVICE_EVENT_TYPE_FORMAT_FAIL,
                       device_path);
 }
 
 }  // namespace file_manager