drive: Stop exposing operation_registry() from DriveServiceInterface

chrome/browser/google_apis/operations_base.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/operations_base.h"
 
 #include "base/json/json_reader.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
@@ skipping 91 matching lines @@
 // used to start fetching user data.
 void AuthOperation::OnGetTokenSuccess(const std::string& access_token,
                                       const base::Time& expiration_time) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   UMA_HISTOGRAM_ENUMERATION("GData.AuthSuccess",
                             kSuccessRatioHistogramSuccess,
                             kSuccessRatioHistogramMaxValue);
 
   callback_.Run(HTTP_SUCCESS, access_token);
-  NotifyFinish(OperationRegistry::OPERATION_COMPLETED);
+  NotifyFinish(OPERATION_COMPLETED);
 }
 
 // Callback for OAuth2AccessTokenFetcher on failure.
 void AuthOperation::OnGetTokenFailure(const GoogleServiceAuthError& error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   LOG(WARNING) << "AuthOperation: token request using refresh token failed"
                << error.ToString();
 
   // There are many ways to fail, but if the failure is due to connection,
   // it's likely that the device is off-line. We treat the error differently
   // so that the file manager works while off-line.
   if (error.state() == GoogleServiceAuthError::CONNECTION_FAILED) {
     UMA_HISTOGRAM_ENUMERATION("GData.AuthSuccess",
                               kSuccessRatioHistogramNoConnection,
                               kSuccessRatioHistogramMaxValue);
     callback_.Run(GDATA_NO_CONNECTION, std::string());
   } else {
     UMA_HISTOGRAM_ENUMERATION("GData.AuthSuccess",
                               kSuccessRatioHistogramFailure,
                               kSuccessRatioHistogramMaxValue);
     callback_.Run(HTTP_UNAUTHORIZED, std::string());
   }
-  NotifyFinish(OperationRegistry::OPERATION_FAILED);
+  NotifyFinish(OPERATION_FAILED);
 }
 
 //============================ UrlFetchOperationBase ===========================
 
 UrlFetchOperationBase::UrlFetchOperationBase(OperationRegistry* registry)
     : OperationRegistry::Operation(registry),
       re_authenticate_count_(0),
       save_temp_file_(false),
       started_(false) {
 }
 
-UrlFetchOperationBase::UrlFetchOperationBase(
-    OperationRegistry* registry,
-    OperationRegistry::OperationType type,
-    const FilePath& path)
+UrlFetchOperationBase::UrlFetchOperationBase(OperationRegistry* registry,
+                                             OperationType type,
+                                             const FilePath& path)
     : OperationRegistry::Operation(registry, type, path),
       re_authenticate_count_(0),
       save_temp_file_(false) {
 }
 
 UrlFetchOperationBase::~UrlFetchOperationBase() {}
 
 void UrlFetchOperationBase::Start(const std::string& auth_token) {
   DCHECK(!auth_token.empty());
 
@@ skipping 76 matching lines @@
     // likely that the failure is due to loss of connection.
     code = GDATA_NO_CONNECTION;
   }
   return code;
 }
 
 void UrlFetchOperationBase::OnProcessURLFetchResultsComplete(bool result) {
   if (result)
     NotifySuccessToOperationRegistry();
   else
-    NotifyFinish(OperationRegistry::OPERATION_FAILED);
+    NotifyFinish(OPERATION_FAILED);
 }
 
 void UrlFetchOperationBase::OnURLFetchComplete(const URLFetcher* source) {
   GDataErrorCode code = GetErrorCode(source);
   DVLOG(1) << "Response headers:\n" << GetResponseHeadersAsString(source);
 
   if (code == HTTP_UNAUTHORIZED) {
     if (!re_authenticate_callback_.is_null() &&
         ++re_authenticate_count_ <= kMaxReAuthenticateAttemptsPerOperation) {
       re_authenticate_callback_.Run(this);
       return;
     }
 
     OnAuthFailed(code);
     return;
   }
 
   // Overridden by each specialization
   ProcessURLFetchResults(source);
 }
 
 void UrlFetchOperationBase::NotifySuccessToOperationRegistry() {
-  NotifyFinish(OperationRegistry::OPERATION_COMPLETED);
+  NotifyFinish(OPERATION_COMPLETED);
 }
 
 void UrlFetchOperationBase::NotifyStartToOperationRegistry() {
   NotifyStart();
 }
 
 void UrlFetchOperationBase::OnAuthFailed(GDataErrorCode code) {
   RunCallbackOnPrematureFailure(code);
 
   // Notify authentication failed.
   NotifyAuthFailed();
 
   // Check if this failed before we even started fetching. If so, register
   // for start so we can properly unregister with finish.
   if (!started_)
     NotifyStart();
 
   // Note: NotifyFinish() must be invoked at the end, after all other callbacks
   // and notifications. Once NotifyFinish() is called, the current instance of
   // gdata operation will be deleted from the OperationRegistry and become
   // invalid.
-  NotifyFinish(OperationRegistry::OPERATION_FAILED);
+  NotifyFinish(OPERATION_FAILED);
 }
 
 std::string UrlFetchOperationBase::GetResponseHeadersAsString(
     const URLFetcher* url_fetcher) {
   // net::HttpResponseHeaders::raw_headers(), as the name implies, stores
   // all headers in their raw format, i.e each header is null-terminated.
   // So logging raw_headers() only shows the first header, which is probably
   // the status line.  GetNormalizedHeaders, on the other hand, will show all
   // the headers, one per line, which is probably what we want.
   std::string headers;
@@ skipping 113 matching lines @@
 }
 
 void GetDataOperation::RunCallback(GDataErrorCode fetch_error_code,
                                    scoped_ptr<base::Value> value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!callback_.is_null())
     callback_.Run(fetch_error_code, value.Pass());
 }
 
 }  // namespace gdata