drive: Stop exposing operation_registry() from DriveServiceInterface

chrome/browser/google_apis/operation_registry.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/google_apis/operation_registry.h"
 
 #include "base/string_number_conversions.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace {
 
 const int64 kNotificationFrequencyInMilliseconds = 1000;
 
 }  // namespace
 
 namespace gdata {
 
-// static
-std::string OperationRegistry::OperationTypeToString(OperationType type) {
+std::string OperationTypeToString(OperationType type) {
   switch (type) {
     case OPERATION_UPLOAD: return "upload";
     case OPERATION_DOWNLOAD: return "download";
     case OPERATION_OTHER: return "other";
   }
   NOTREACHED();
   return "unknown_transfer_state";
 }
 
-// static
-std::string OperationRegistry::OperationTransferStateToString(
-    OperationTransferState state) {
+std::string OperationTransferStateToString(OperationTransferState state) {
   switch (state) {
     case OPERATION_NOT_STARTED: return "not_started";
     case OPERATION_STARTED: return "started";
     case OPERATION_IN_PROGRESS: return "in_progress";
     case OPERATION_COMPLETED: return "completed";
     case OPERATION_FAILED: return "failed";
     // Suspended state is opaque to users and looks as same as "in_progress".
     case OPERATION_SUSPENDED: return "in_progress";
   }
   NOTREACHED();
   return "unknown_transfer_state";
 }
 
-OperationRegistry::ProgressStatus::ProgressStatus(OperationType type,
-                                                       const FilePath& path)
+OperationProgressStatus::OperationProgressStatus(OperationType type,
+                                                 const FilePath& path)
     : operation_id(-1),
       operation_type(type),
       file_path(path),
       transfer_state(OPERATION_NOT_STARTED),
       progress_current(0),
       progress_total(-1) {
 }
 
-std::string OperationRegistry::ProgressStatus::DebugString() const {
+std::string OperationProgressStatus::DebugString() const {
   std::string str;
   str += "id=";
   str += base::IntToString(operation_id);
   str += " type=";
   str += OperationTypeToString(operation_type);
   str += " path=";
   str += file_path.AsUTF8Unsafe();
   str += " state=";
   str += OperationTransferStateToString(transfer_state);
   str += " progress=";
   str += base::Int64ToString(progress_current);
   str += "/";
   str += base::Int64ToString(progress_total);
   return str;
 }
 
 OperationRegistry::Operation::Operation(OperationRegistry* registry)
     : registry_(registry),
-      progress_status_(OperationRegistry::OPERATION_OTHER, FilePath()) {
+      progress_status_(OPERATION_OTHER, FilePath()) {
 }
 
 OperationRegistry::Operation::Operation(OperationRegistry* registry,
-                                             OperationType type,
-                                             const FilePath& path)
+                                        OperationType type,
+                                        const FilePath& path)
     : registry_(registry),
       progress_status_(type, path) {
 }
 
 OperationRegistry::Operation::~Operation() {
   DCHECK(progress_status_.transfer_state == OPERATION_COMPLETED ||
          progress_status_.transfer_state == OPERATION_SUSPENDED ||
          progress_status_.transfer_state == OPERATION_FAILED);
 }
 
@@ skipping 131 matching lines @@
   DCHECK(operation);
 
   DVLOG(1) << "GDataOperation[" << id << "] finished.";
   if (IsFileTransferOperation(operation))
     NotifyStatusToObservers();
   in_flight_operations_.Remove(id);
 }
 
 void OperationRegistry::OnOperationResume(
     OperationRegistry::Operation* operation,
-    OperationRegistry::ProgressStatus* new_status) {
+    OperationProgressStatus* new_status) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Find the corresponding suspended task.
   Operation* suspended = NULL;
   for (OperationIDMap::iterator iter(&in_flight_operations_);
        !iter.IsAtEnd();
        iter.Advance()) {
     Operation* in_flight_operation = iter.GetCurrentValue();
-    const ProgressStatus& status = in_flight_operation->progress_status();
+    const OperationProgressStatus& status =
+        in_flight_operation->progress_status();
     if (status.transfer_state == OPERATION_SUSPENDED &&
         status.file_path == operation->progress_status().file_path) {
       suspended = in_flight_operation;
       break;
     }
   }
   DCHECK(suspended);
 
   // Copy the progress status.
-  const ProgressStatus& old_status = suspended->progress_status();
+  const OperationProgressStatus& old_status = suspended->progress_status();
   OperationID old_id = old_status.operation_id;
 
   new_status->progress_current = old_status.progress_current;
   new_status->progress_total = old_status.progress_total;
   new_status->start_time = old_status.start_time;
 
   // Remove the old one and initiate the new operation.
   in_flight_operations_.Remove(old_id);
   new_status->operation_id = in_flight_operations_.Add(operation);
   DVLOG(1) << "GDataOperation[" << old_id << " -> " <<
@@ skipping 19 matching lines @@
   DVLOG(1) << "GDataOperation authentication failed.";
   FOR_EACH_OBSERVER(Observer, observer_list_, OnAuthenticationFailed());
 }
 
 bool OperationRegistry::IsFileTransferOperation(
     const Operation* operation) const {
   OperationType type = operation->progress_status().operation_type;
   return type == OPERATION_UPLOAD || type == OPERATION_DOWNLOAD;
 }
 
-OperationRegistry::ProgressStatusList
-OperationRegistry::GetProgressStatusList() {
+OperationProgressStatusList OperationRegistry::GetProgressStatusList() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  ProgressStatusList status_list;
+  OperationProgressStatusList status_list;
   for (OperationIDMap::const_iterator iter(&in_flight_operations_);
        !iter.IsAtEnd();
        iter.Advance()) {
     const Operation* operation = iter.GetCurrentValue();
     if (IsFileTransferOperation(operation))
       status_list.push_back(operation->progress_status());
   }
   return status_list;
 }
 
 bool OperationRegistry::ShouldNotifyStatusNow(
-    const ProgressStatusList& list) {
+    const OperationProgressStatusList& list) {
   if (!do_notification_frequency_control_)
     return true;
 
   base::Time now = base::Time::Now();
 
   // If it is a first event, or some time abnormality is detected, we should
   // not skip this notification.
   if (last_notification_.is_null() || now < last_notification_) {
     last_notification_ = now;
     return true;
@@ skipping 14 matching lines @@
       last_notification_ = now;
       return true;
     }
   }
 
   // Otherwise we can skip it.
   return false;
 }
 
 void OperationRegistry::NotifyStatusToObservers() {
-  ProgressStatusList list(GetProgressStatusList());
+  OperationProgressStatusList list(GetProgressStatusList());
   if (ShouldNotifyStatusNow(list))
     FOR_EACH_OBSERVER(Observer, observer_list_, OnProgressUpdate(list));
 }
 
 }  // namespace gdata