Remove "GData" prefix from non-GData specific classes

chrome/browser/chromeos/gdata/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/chromeos/gdata/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 65 matching lines @@
                << data;
   }
 }
 
 }  // namespace
 
 namespace gdata {
 
 //================================ AuthOperation ===============================
 
-AuthOperation::AuthOperation(GDataOperationRegistry* registry,
+AuthOperation::AuthOperation(OperationRegistry* registry,
                              const AuthStatusCallback& callback,
                              const std::string& refresh_token)
-    : GDataOperationRegistry::Operation(registry),
+    : OperationRegistry::Operation(registry),
       refresh_token_(refresh_token), callback_(callback) {
 }
 
 AuthOperation::~AuthOperation() {}
 
 void AuthOperation::Start() {
   DCHECK(!refresh_token_.empty());
   std::vector<std::string> scopes;
   if (gdata::util::IsDriveV2ApiEnabled()) {
     scopes.push_back(kDriveScope);
@@ skipping 26 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(GDataOperationRegistry::OPERATION_COMPLETED);
+  NotifyFinish(OperationRegistry::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(GDataOperationRegistry::OPERATION_FAILED);
+  NotifyFinish(OperationRegistry::OPERATION_FAILED);
 }
 
 //============================ UrlFetchOperationBase ===========================
 
-UrlFetchOperationBase::UrlFetchOperationBase(GDataOperationRegistry* registry)
-    : GDataOperationRegistry::Operation(registry),
+UrlFetchOperationBase::UrlFetchOperationBase(OperationRegistry* registry)
+    : OperationRegistry::Operation(registry),
       re_authenticate_count_(0),
       save_temp_file_(false),
       started_(false) {
 }
 
 UrlFetchOperationBase::UrlFetchOperationBase(
-    GDataOperationRegistry* registry,
-    GDataOperationRegistry::OperationType type,
+    OperationRegistry* registry,
+    OperationRegistry::OperationType type,
     const FilePath& path)
-    : GDataOperationRegistry::Operation(registry, type, 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());
 
   GURL url = GetURL();
@@ skipping 75 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(GDataOperationRegistry::OPERATION_FAILED);
+    NotifyFinish(OperationRegistry::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(GDataOperationRegistry::OPERATION_COMPLETED);
+  NotifyFinish(OperationRegistry::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 GDataOperationRegistry and become
+  // gdata operation will be deleted from the OperationRegistry and become
   // invalid.
-  NotifyFinish(GDataOperationRegistry::OPERATION_FAILED);
+  NotifyFinish(OperationRegistry::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;
   // Check that response code indicates response headers are valid (i.e. not
   // malformed) before we retrieve the headers.
   if (url_fetcher->GetResponseCode() == URLFetcher::RESPONSE_CODE_INVALID) {
     headers.assign("Response headers are malformed!!");
   } else {
     url_fetcher->GetResponseHeaders()->GetNormalizedHeaders(&headers);
   }
   return headers;
 }
 
 //============================ EntryActionOperation ============================
 
-EntryActionOperation::EntryActionOperation(GDataOperationRegistry* registry,
+EntryActionOperation::EntryActionOperation(OperationRegistry* registry,
                                            const EntryActionCallback& callback,
                                            const GURL& document_url)
     : UrlFetchOperationBase(registry),
       callback_(callback),
       document_url_(document_url) {
 }
 
 EntryActionOperation::~EntryActionOperation() {}
 
 void EntryActionOperation::ProcessURLFetchResults(const URLFetcher* source) {
   if (!callback_.is_null()) {
     GDataErrorCode code = GetErrorCode(source);
     callback_.Run(code, document_url_);
   }
   const bool success = true;
   OnProcessURLFetchResultsComplete(success);
 }
 
 void EntryActionOperation::RunCallbackOnPrematureFailure(GDataErrorCode code) {
   if (!callback_.is_null())
     callback_.Run(code, document_url_);
 }
 
 //============================== GetDataOperation ==============================
 
-GetDataOperation::GetDataOperation(GDataOperationRegistry* registry,
+GetDataOperation::GetDataOperation(OperationRegistry* registry,
                                    const GetDataCallback& callback)
     : UrlFetchOperationBase(registry),
       callback_(callback),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
 }
 
 GetDataOperation::~GetDataOperation() {}
 
 void GetDataOperation::ProcessURLFetchResults(const URLFetcher* source) {
   std::string data;
@@ skipping 64 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