drive: Stop exposing operation_registry() from DriveServiceInterface

chrome/browser/chromeos/system/ash_system_tray_delegate.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/system/ash_system_tray_delegate.h"
 
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/audio/audio_observer.h"
 #include "ash/system/bluetooth/bluetooth_observer.h"
@@ skipping 35 matching lines @@
 #include "chrome/browser/chromeos/login/message_bubble.h"
 #include "chrome/browser/chromeos/login/user.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/mobile_config.h"
 #include "chrome/browser/chromeos/status/data_promo_notification.h"
 #include "chrome/browser/chromeos/status/network_menu.h"
 #include "chrome/browser/chromeos/status/network_menu_icon.h"
 #include "chrome/browser/chromeos/system/timezone_settings.h"
 #include "chrome/browser/chromeos/system_key_event_listener.h"
 #include "chrome/browser/google_apis/gdata_util.h"
-#include "chrome/browser/google_apis/operation_registry.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/ash/volume_controller_chromeos.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/singleton_tabs.h"
 #include "chrome/browser/upgrade_detector.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager_client.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/user_metrics.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using gdata::DriveSystemService;
 using gdata::DriveSystemServiceFactory;
-using gdata::OperationRegistry;
 
 namespace chromeos {
 
 namespace {
 
 // Time delay for rechecking gdata operation when we suspect that there will
 // be no upcoming activity notifications that need to be pushed to UI.
 const int kGDataOperationRecheckDelayMs = 5000;
 
 ash::NetworkIconInfo CreateNetworkIconInfo(const Network* network,
                                            NetworkMenu* network_menu) {
   ash::NetworkIconInfo info;
   info.name = UTF8ToUTF16(network->name());
   info.image = NetworkMenuIcon::GetImage(network, NetworkMenuIcon::COLOR_DARK);
   info.service_path = network->service_path();
   info.highlight = network->connected() || network->connecting();
   return info;
 }
 
 void ExtractIMEInfo(const input_method::InputMethodDescriptor& ime,
                     const input_method::InputMethodUtil& util,
                     ash::IMEInfo* info) {
   info->id = ime.id();
   info->name = util.GetInputMethodLongName(ime);
   info->short_name = util.GetInputMethodShortName(ime);
   info->third_party = ime.third_party();
 }
 
 ash::DriveOperationStatusList GetDriveStatusList(
-    const std::vector<OperationRegistry::ProgressStatus>& list) {
+    const gdata::OperationProgressStatusList& list) {
   ash::DriveOperationStatusList results;
-  for (OperationRegistry::ProgressStatusList::const_iterator it =
-          list.begin();
+  for (gdata::OperationProgressStatusList::const_iterator it = list.begin();
        it != list.end(); ++it) {
     ash::DriveOperationStatus status;
     status.file_path = it->file_path;
     status.progress = it->progress_total == 0 ? 0.0 :
         static_cast<double>(it->progress_current) /
             static_cast<double>(it->progress_total);
     status.type = static_cast<ash::DriveOperationStatus::OperationType>(
         it->operation_type);
     status.state = static_cast<ash::DriveOperationStatus::OperationState>(
         it->transfer_state);
@@ skipping 20 matching lines @@
 
 class SystemTrayDelegate : public ash::SystemTrayDelegate,
                            public AudioHandler::VolumeObserver,
                            public PowerManagerClient::Observer,
                            public SessionManagerClient::Observer,
                            public NetworkMenuIcon::Delegate,
                            public NetworkMenu::Delegate,
                            public NetworkLibrary::NetworkManagerObserver,
                            public NetworkLibrary::NetworkObserver,
                            public NetworkLibrary::CellularDataPlanObserver,
-                           public gdata::OperationRegistry::Observer,
+                           public gdata::DriveServiceObserver,
                            public content::NotificationObserver,
                            public input_method::InputMethodManager::Observer,
                            public system::TimezoneSettings::Observer,
                            public BluetoothAdapter::Observer,
                            public SystemKeyEventListener::CapsLockObserver,
                            public ash::NetworkTrayDelegate {
  public:
   explicit SystemTrayDelegate(ash::SystemTray* tray)
       : tray_(tray),
         ui_weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(
@@ skipping 69 matching lines @@
     }
     input_method::InputMethodManager::GetInstance()->RemoveObserver(this);
     system::TimezoneSettings::GetInstance()->RemoveObserver(this);
     if (SystemKeyEventListener::GetInstance())
       SystemKeyEventListener::GetInstance()->RemoveCapsLockObserver(this);
     bluetooth_adapter_->RemoveObserver(this);
 
     // Stop observing gdata operations.
     DriveSystemService* system_service = FindDriveSystemService();
     if (system_service) {
-      system_service->drive_service()->operation_registry()->
-          RemoveObserver(this);
+      system_service->drive_service()->RemoveObserver(this);
     }
   }
 
   // Overridden from ash::SystemTrayDelegate:
   virtual bool GetTrayVisibilityOnStartup() OVERRIDE {
     // In case of OOBE / sign in screen tray will be shown later.
     return UserManager::Get()->IsUserLoggedIn();
   }
 
   virtual const string16 GetUserDisplayName() const OVERRIDE {
@@ skipping 185 matching lines @@
   virtual void ActivateIMEProperty(const std::string& key) OVERRIDE {
     input_method::InputMethodManager::GetInstance()->
         ActivateInputMethodProperty(key);
   }
 
   virtual void CancelDriveOperation(const FilePath& file_path) OVERRIDE {
     DriveSystemService* system_service = FindDriveSystemService();
     if (!system_service)
       return;
 
-    system_service->drive_service()->operation_registry()->CancelForFilePath(
-        file_path);
+    system_service->drive_service()->CancelForFilePath(file_path);
   }
 
   virtual void GetDriveOperationStatusList(
       ash::DriveOperationStatusList* list) OVERRIDE {
     DriveSystemService* system_service = FindDriveSystemService();
     if (!system_service)
       return;
 
     *list = GetDriveStatusList(
-        system_service->drive_service()->operation_registry()->
-            GetProgressStatusList());
+        system_service->drive_service()->GetProgressStatusList());
   }
 
 
   virtual void GetMostRelevantNetworkIcon(ash::NetworkIconInfo* info,
                                           bool dark) OVERRIDE {
     NetworkMenuIcon* icon =
         dark ? network_icon_dark_.get() : network_icon_.get();
     info->image = icon->GetIconAndText(&info->description);
     info->tray_icon_visible = icon->ShouldShowIconInTray();
   }
@@ skipping 243 matching lines @@
     UpdateClockType(profile->GetPrefs());
     search_key_mapped_to_ =
         profile->GetPrefs()->GetInteger(prefs::kLanguageXkbRemapSearchKeyTo);
   }
 
   void ObserveGDataUpdates() {
     DriveSystemService* system_service = FindDriveSystemService();
     if (!system_service)
       return;
 
-    system_service->drive_service()->operation_registry()->AddObserver(this);
+    system_service->drive_service()->AddObserver(this);
   }
 
   void UpdateClockType(PrefService* service) {
     clock_type_ = service->GetBoolean(prefs::kUse24HourClock) ?
         base::k24HourClock : base::k12HourClock;
     ash::ClockObserver* observer = tray_->clock_observer();
     if (observer)
       observer->OnDateFormatChanged();
   }
 
@@ skipping 350 matching lines @@
   virtual void InputMethodChanged(
       input_method::InputMethodManager* manager, bool show_message) OVERRIDE {
     NotifyRefreshIME(show_message);
   }
 
   virtual void InputMethodPropertyChanged(
       input_method::InputMethodManager* manager) OVERRIDE {
     NotifyRefreshIME(false);
   }
 
-  // gdata::OperationRegistry::Observer overrides.
+  // gdata::DriveServiceObserver overrides.
   virtual void OnProgressUpdate(
-      const OperationRegistry::ProgressStatusList& list) {
+      const gdata::OperationProgressStatusList& list) OVERRIDE {
     std::vector<ash::DriveOperationStatus> ui_list = GetDriveStatusList(list);
     NotifyRefreshDrive(ui_list);
 
     // If we have something to report right now (i.e. completion status only),
     // we need to delayed re-check the status in few seconds to ensure we
     // raise events that will let us properly clear the uber tray state.
     if (list.size() > 0) {
       bool has_in_progress_items = false;
-      for (OperationRegistry::ProgressStatusList::const_iterator it =
-               list.begin();
+      for (gdata::OperationProgressStatusList::const_iterator it = list.begin();
           it != list.end(); ++it) {
-        if (it->transfer_state ==
-                OperationRegistry::OPERATION_STARTED ||
-            it->transfer_state ==
-                OperationRegistry::OPERATION_IN_PROGRESS ||
-            it->transfer_state ==
-                OperationRegistry::OPERATION_SUSPENDED) {
+        if (it->transfer_state == gdata::OPERATION_STARTED ||
+            it->transfer_state == gdata::OPERATION_IN_PROGRESS ||
+            it->transfer_state == gdata::OPERATION_SUSPENDED) {
           has_in_progress_items = true;
           break;
         }
       }
 
       if (!has_in_progress_items) {
         content::BrowserThread::PostDelayedTask(
             content::BrowserThread::UI,
             FROM_HERE,
             base::Bind(&SystemTrayDelegate::RecheckGDataOperations,
                        ui_weak_ptr_factory_->GetWeakPtr()),
             base::TimeDelta::FromMilliseconds(kGDataOperationRecheckDelayMs));
       }
     }
 
   }
 
   // Pulls the list of ongoing drive operations and initiates status update.
   // This method is needed to ensure delayed cleanup of the latest reported
   // status in UI in cases when there are no new changes coming (i.e. when the
   // last set of transfer operations completed).
   void RecheckGDataOperations() {
     DriveSystemService* system_service = FindDriveSystemService();
     if (!system_service)
       return;
 
-    OnProgressUpdate(system_service->drive_service()->operation_registry()->
-        GetProgressStatusList());
+    OnProgressUpdate(system_service->drive_service()->GetProgressStatusList());
   }
 
   DriveSystemService* FindDriveSystemService() {
     Profile* profile = ProfileManager::GetDefaultProfile();
     if (!gdata::util::IsGDataAvailable(profile))
       return NULL;
     return DriveSystemServiceFactory::FindForProfile(profile);
   }
 
   // Overridden from system::TimezoneSettings::Observer.
@@ skipping 107 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(SystemTrayDelegate);
 };
 
 }  // namespace
 
 ash::SystemTrayDelegate* CreateSystemTrayDelegate(ash::SystemTray* tray) {
   return new chromeos::SystemTrayDelegate(tray);
 }
 
 }  // namespace chromeos