drive: Rename 'gdata' namespace to 'drive' in chrome/browser/chromeos/drive

chrome/browser/chromeos/drive/file_system/remove_operation.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/drive/file_system/remove_operation.h"
 
 #include <math.h>
 
 #include "base/rand_util.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/drive_cache.h"
 #include "chrome/browser/chromeos/drive/drive_file_system.h"
 #include "chrome/browser/chromeos/drive/drive_file_system_util.h"
 #include "chrome/browser/chromeos/drive/drive_service_interface.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
-namespace gdata {
+namespace drive {
 
 namespace {
 int kMaxRetries = 5;
 }
 
 namespace file_system {
 
 RemoveOperation::RemoveOperation(DriveServiceInterface* drive_service,
                                          DriveFileSystem* file_system,
                                          DriveCache* cache)
@@ skipping 55 matching lines @@
                  weak_ptr_factory_.GetWeakPtr(),
                  callback,
                  retry_count + 1,
                  base::Passed(&entry_proto)));
 }
 
 void RemoveOperation::RetryIfNeeded(
     const FileOperationCallback& callback,
     int retry_count,
     scoped_ptr<DriveEntryProto> entry_proto,
-    GDataErrorCode status,
+    gdata::GDataErrorCode status,
     const GURL& /* document_url */) {
   // If the call failed due to flooding the server, and we haven't hit the
   // maximum number of retries, throttle and retry.
   //
   // TODO(zork): Move this retry logic into the scheduler when it is completed.
-  if ((status == HTTP_SERVICE_UNAVAILABLE ||
-       status == HTTP_INTERNAL_SERVER_ERROR) &&
+  if ((status == gdata::HTTP_SERVICE_UNAVAILABLE ||
+       status == gdata::HTTP_INTERNAL_SERVER_ERROR) &&
       retry_count < kMaxRetries) {
     base::TimeDelta delay =
         base::TimeDelta::FromSeconds(pow(2, retry_count)) +
         base::TimeDelta::FromMilliseconds(base::RandInt(0, 1000));
 
     VLOG(1) << "Throttling for " << delay.InMillisecondsF();
     const bool posted = base::MessageLoopProxy::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&RemoveOperation::DoDelete,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback,
                    retry_count,
                    base::Passed(&entry_proto)),
         delay);
     DCHECK(posted);
   } else {
     // If the operation completed, or we hit max retries, continue.
     RemoveResourceLocally(callback,
                           entry_proto->resource_id(),
                           status);
   }
 }
 
 void RemoveOperation::RemoveResourceLocally(
     const FileOperationCallback& callback,
     const std::string& resource_id,
-    GDataErrorCode status) {
+    gdata::GDataErrorCode status) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK) {
     callback.Run(error);
     return;
   }
 
   file_system_->ResourceMetadata()->RemoveEntryFromParent(
@@ skipping 10 matching lines @@
     DriveFileError error,
     const FilePath& directory_path) {
   if (error == DRIVE_FILE_OK)
     file_system_->OnDirectoryChanged(directory_path);
 
   if (!callback.is_null())
     callback.Run(error);
 }
 
 }  // namespace file_system
-}  // namespace gdata
+}  // namespace drive