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 75 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.

[mtomasz, 2013/12/25 01:19:56]

nit: Please update the comment.

[hirono, 2013/12/25 02:06:55]

Done.

-scoped_ptr<base::DictionaryValue> JobInfoToDictionaryValue(
+void JobInfoToDictionaryValue(
     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> >

[mtomasz, 2013/12/25 01:19:56]

How about ScopedVector?

https://groups.google.com/a/chromium.org/forum/#!topic/chromium-dev/6i8vKfmHnJQ

[hirono, 2013/12/25 02:06:55]

Because IDL generated methods takes
std::vector<linked_ptr<file_browser_private::FileTransferStatus> >, we cannot
use ScopedVector here.

+      status_list;
+  status_list.resize(drive_jobs_.size());
+  size_t i = 0;
   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());
+    JobInfoToDictionaryValue(kFileManagerAppId,
+                             iter->second.status,
+                             iter->second.job_info,
+                             status_list[i++].get());
   }
 
-  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;
   }
@@ skipping 23 matching lines @@
     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,
+        args.Pass());
   }
 }
 
 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 128 matching lines @@
         base::TimeDelta::FromSeconds(4));
   } else {
     notifications_->HideNotification(DesktopNotifications::FORMAT_START,
                                      device_path);
     notifications_->ShowNotification(DesktopNotifications::FORMAT_FAIL,
                                      device_path);
   }
 }
 
 }  // namespace file_manager