drive: Add information about in-flight operations to chrome:drive-internals

chrome/browser/ui/webui/chromeos/drive_internals_ui.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/ui/webui/chromeos/drive_internals_ui.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/stringprintf.h"
 #include "base/memory/weak_ptr.h"
 #include "base/path_service.h"
 #include "base/sys_info.h"
 #include "chrome/browser/chromeos/gdata/auth_service.h"
 #include "chrome/browser/chromeos/gdata/drive.pb.h"
 #include "chrome/browser/chromeos/gdata/drive_cache.h"
 #include "chrome/browser/chromeos/gdata/drive_file_system_interface.h"
 #include "chrome/browser/chromeos/gdata/drive_service_interface.h"
 #include "chrome/browser/chromeos/gdata/drive_system_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
+#include "chrome/browser/chromeos/gdata/operation_registry.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_data_source.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_message_handler.h"
 #include "grit/browser_resources.h"
 
 using content::BrowserThread;
 
@@ skipping 158 matching lines @@
       const std::vector<std::string>& resource_ids);
 
   // Called when GetCacheEntryOnUIThread() is complete.
   void OnGetCacheEntry(const std::string& resource_id,
                        bool success,
                        const gdata::DriveCacheEntry& cache_entry);
 
   // Called when GetFreeDiskSpace() is complete.
   void OnGetFreeDiskSpace(base::DictionaryValue* local_storage_summary);
 
+  // Called when the page requests periodic update.
+  void OnPeriodicUpdate(const base::ListValue* args);
+
+  // Updates the summary about in-flight operations.
+  void UpdateInFlightOperations(
+      const gdata::DriveServiceInterface* drive_service);
+
   // The number of pending ReadDirectoryByPath() calls.
   int num_pending_reads_;
   base::WeakPtrFactory<DriveInternalsWebUIHandler> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(DriveInternalsWebUIHandler);
 };
 
 void DriveInternalsWebUIHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "pageLoaded",
       base::Bind(&DriveInternalsWebUIHandler::OnPageLoaded,
                  weak_ptr_factory_.GetWeakPtr()));
+  web_ui()->RegisterMessageCallback(
+      "periodicUpdate",
+      base::Bind(&DriveInternalsWebUIHandler::OnPeriodicUpdate,
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 gdata::DriveSystemService* DriveInternalsWebUIHandler::GetSystemService() {
   Profile* profile = Profile::FromWebUI(web_ui());
   return gdata::DriveSystemServiceFactory::GetForProfile(profile);
 }
 
 void DriveInternalsWebUIHandler::OnPageLoaded(const base::ListValue* args) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 149 matching lines @@
 
 void DriveInternalsWebUIHandler::OnGetFreeDiskSpace(
     base::DictionaryValue* local_storage_summary) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(local_storage_summary);
 
   web_ui()->CallJavascriptFunction(
       "updateLocalStorageUsage", *local_storage_summary);
 }
 
+void DriveInternalsWebUIHandler::OnPeriodicUpdate(const base::ListValue* args) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  gdata::DriveSystemService* system_service = GetSystemService();
+  // |system_service| may be NULL in the guest/incognito mode.
+  if (!system_service)
+    return;
+
+  gdata::DriveServiceInterface* drive_service = system_service->drive_service();
+  DCHECK(drive_service);
+
+  UpdateInFlightOperations(drive_service);
+}
+
+void DriveInternalsWebUIHandler::UpdateInFlightOperations(
+    const gdata::DriveServiceInterface* drive_service) {
+  std::vector<gdata::OperationRegistry::ProgressStatus>
+      progress_status_list = drive_service->operation_registry()->
+      GetProgressStatusList();
+
+  base::ListValue in_flight_operations;
+  for (size_t i = 0; i < progress_status_list.size(); ++i) {
+    const gdata::OperationRegistry::ProgressStatus status =
+        progress_status_list[i];
+
+    base::DictionaryValue* dict = new DictionaryValue;
+    dict->SetInteger("operation_id", status.operation_id);
+    dict->SetString(
+        "operation_type",
+        gdata::OperationRegistry::OperationTypeToString(status.operation_type));
+    dict->SetString("file_path", status.file_path.AsUTF8Unsafe());
+    dict->SetString(
+        "transfer_state",
+        gdata::OperationRegistry::OperationTransferStateToString(
+            status.transfer_state));
+    dict->SetString(
+        "start_time",
+        gdata::util::FormatTimeAsStringLocaltime(status.start_time));
+    dict->SetDouble("progress_current", status.progress_current);
+    dict->SetDouble("progress_total", status.progress_total);
+    in_flight_operations.Append(dict);
+  }
+  web_ui()->CallJavascriptFunction("updateInFlightOperations",
+                                   in_flight_operations);
+}
+
 }  // namespace
 
 DriveInternalsUI::DriveInternalsUI(content::WebUI* web_ui)
     : WebUIController(web_ui) {
   web_ui->AddMessageHandler(new DriveInternalsWebUIHandler());
 
   ChromeWebUIDataSource* source =
       new ChromeWebUIDataSource(chrome::kChromeUIDriveInternalsHost);
   source->add_resource_path("drive_internals.css", IDR_DRIVE_INTERNALS_CSS);
   source->add_resource_path("drive_internals.js", IDR_DRIVE_INTERNALS_JS);
   source->set_default_resource(IDR_DRIVE_INTERNALS_HTML);
 
   Profile* profile = Profile::FromWebUI(web_ui);
   ChromeURLDataManager::AddDataSource(profile, source);
 }
 
 }  // namespace chromeos