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

chrome/browser/chromeos/drive/drive_uploader.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_DRIVE_DRIVE_UPLOADER_H_
 #define CHROME_BROWSER_CHROMEOS_DRIVE_DRIVE_UPLOADER_H_
 
 #include <map>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/chromeos/drive/drive_file_error.h"
 #include "chrome/browser/google_apis/drive_upload_mode.h"
 #include "chrome/browser/google_apis/gdata_errorcode.h"
 #include "chrome/browser/google_apis/gdata_wapi_parser.h"
 #include "net/base/file_stream.h"
 #include "net/base/completion_callback.h"
 #include "net/base/file_stream.h"
 
 class GURL;
 
 namespace content {
 class DownloadItem;
 }
 
 namespace gdata {
+struct ResumeUploadResponse;
+}
+
+namespace drive {
 
 class MockDriveUploader;
 class DriveServiceInterface;
-struct ResumeUploadResponse;
 
 // Callback to be invoked once the upload has completed.
 typedef base::Callback<void(DriveFileError error,
     const FilePath& drive_path,
     const FilePath& file_path,
-    scoped_ptr<DocumentEntry> document_entry)> UploadCompletionCallback;
+    scoped_ptr<gdata::DocumentEntry> document_entry)> UploadCompletionCallback;
 
 // Callback to be invoked once the upoader is ready to upload.
 typedef base::Callback<void(int32 upload_id)> UploaderReadyCallback;
 
 class DriveUploaderInterface {
  public:
   virtual ~DriveUploaderInterface() {}
 
   // Uploads a new file.
   // Returns the upload_id.
@@ skipping 92 matching lines @@
 
     int upload_id;  // id of this upload.
     FilePath file_path;  // The path of the file to be uploaded.
     int64 file_size;  // Last known size of the file.
 
     // TODO(zelirag, achuith): Make this string16.
     std::string title;  // Title to be used for file to be uploaded.
     std::string content_type;  // Content-Type of file.
     int64 content_length;  // Header content-Length.
 
-    UploadMode upload_mode;
+    gdata::UploadMode upload_mode;
 
     // Location URL used to get |upload_location| with InitiateUpload.
     GURL initial_upload_location;
 
     // Location URL where file is to be uploaded to, returned from
     // InitiateUpload. Used for the subsequent ResumeUpload requests.
     GURL upload_location;
 
     // Final path in gdata. Looks like /special/drive/MyFolder/MyFile.
     FilePath drive_path;
@@ skipping 16 matching lines @@
     int64 start_range;
     int64 end_range;  // End of range of contents currently stored in |buf|.
 
     bool all_bytes_present;  // Whether all bytes of this file are present.
     bool upload_paused;  // Whether this file's upload has been paused.
 
     bool should_retry_file_open;  // Whether we should retry opening this file.
     int num_file_open_tries;  // Number of times we've tried to open this file.
 
     // Will be set once the upload is complete.
-    scoped_ptr<DocumentEntry> entry;
+    scoped_ptr<gdata::DocumentEntry> entry;
 
     // Callback to be invoked once the uploader is ready to upload.
     UploaderReadyCallback ready_callback;
 
     // Callback to be invoked once the upload has finished.
     UploadCompletionCallback completion_callback;
   };
 
   // Indicates step in which we try to open a file.
   // Retrying happens in FILE_OPEN_UPDATE_UPLOAD step.
   enum FileOpenType {
     FILE_OPEN_START_UPLOAD,
     FILE_OPEN_UPDATE_UPLOAD
   };
 
   // Lookup UploadFileInfo* in pending_uploads_.
   UploadFileInfo* GetUploadFileInfo(int upload_id) const;
 
   // Open the file.
   void OpenFile(UploadFileInfo* upload_file_info, FileOpenType open_type);
 
   // net::FileStream::Open completion callback. The result of the file
   // open operation is passed as |result|.
   void OpenCompletionCallback(FileOpenType open_type,
                               int upload_id,
                               int result);
 
   // DriveService callback for InitiateUpload.
   void OnUploadLocationReceived(int upload_id,
-                                GDataErrorCode code,
+                                gdata::GDataErrorCode code,
                                 const GURL& upload_location);
 
   // Uploads the next chunk of data from the file.
   void UploadNextChunk(UploadFileInfo* upload_file_info);
 
   // net::FileStream::Read completion callback.
   void ReadCompletionCallback(int upload_id,
       int bytes_to_read,
       int bytes_read);
 
   // Calls DriveService's ResumeUpload with the current upload info.
   void ResumeUpload(int upload_id);
 
   // DriveService callback for ResumeUpload.
-  void OnResumeUploadResponseReceived(int upload_id,
-                                      const ResumeUploadResponse& response,
-                                      scoped_ptr<DocumentEntry> entry);
+  void OnResumeUploadResponseReceived(
+      int upload_id,
+      const gdata::ResumeUploadResponse& response,
+      scoped_ptr<gdata::DocumentEntry> entry);
 
   // Initiate the upload.
   void InitiateUpload(UploadFileInfo* uploader_file_info);
 
   // Handle failed uploads.
   void UploadFailed(UploadFileInfo* upload_file_info,
                     DriveFileError error);
 
   // Removes |upload_file_info| from UploadFileInfoMap |pending_uploads_|.
   // After its removal from the map, |upload_file_info| is deleted.
@@ skipping 16 matching lines @@
   // in DriveUploader dtor (i.e. we can assume |this| takes their ownership).
   UploadFileInfoMap pending_uploads_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<DriveUploader> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DriveUploader);
 };
 
-}  // namespace gdata
+}  // namespace drive
 
 #endif  // CHROME_BROWSER_CHROMEOS_DRIVE_DRIVE_UPLOADER_H_