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

chrome/browser/chromeos/drive/drive_protocol_handler.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/drive_protocol_handler.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 20 matching lines @@
 #include "net/base/file_stream.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job.h"
 
 using content::BrowserThread;
 
-namespace gdata {
+namespace drive {
 
 namespace {
 
 const net::UnescapeRule::Type kUrlPathUnescapeMask =
     net::UnescapeRule::SPACES |
     net::UnescapeRule::URL_SPECIAL_CHARS |
     net::UnescapeRule::CONTROL_CHARS;
 
 const int kHTTPOk = 200;
 const int kHTTPNotAllowed = 403;
@@ skipping 94 matching lines @@
 
  private:
   // Helper for Start() to let us start asynchronously.
   void StartAsync(DriveFileSystemInterface** file_system);
 
   // Helper methods for Delegate::OnUrlFetchDownloadData and ReadRawData to
   // receive download data and copy to response buffer.
   // For detailed description of logic, refer to comments in definitions of
   // Start() and ReadRawData().
 
-  void OnUrlFetchDownloadData(GDataErrorCode error,
+  void OnUrlFetchDownloadData(gdata::GDataErrorCode error,
                               scoped_ptr<std::string> download_data);
   // Called from ReadRawData, returns true if data is ready, false otherwise.
   bool ContinueReadFromDownloadData(int* bytes_read);
   // Copies from download buffer into response buffer.
   bool ReadFromDownloadData();
 
   // Helper callback for handling async responses from
   // DriveFileSystem::GetFileByResourceId().
   void OnGetFileByResourceId(DriveFileError error,
                              const FilePath& local_file_path,
@@ skipping 87 matching lines @@
   //    should still be asynchronous, so that all error reporting and data
   //    callbacks happen as they would for network requests, so we should still
   //    post task to same thread to actually start request.
   // 2) Reply task StartAsync is invoked.
   // 3) If unable to get file system or request method is not GET, report start
   //    error and bail out.
   // 4) Otherwise, parse request url to get resource id and file name.
   // 5) Find file from file system to get its mime type, drive file path and
   //    size of physical file.
   // 6) Get file from file system asynchronously with both GetFileCallback and
-  //    GetContentCallback - this would either get it from cache or
+  //    gdata::GetContentCallback - this would either get it from cache or
   //    download it from Drive.
   // 7) If file is downloaded from Drive:
   //    7.1) Whenever net::URLFetcherCore::OnReadCompleted() receives a part
   //         of the response, it invokes
   //         net::URLFetcherDelegate::OnURLFetchDownloadData() if
   //         net::URLFetcherDelegate::ShouldSendDownloadData() is true.
   //    7.2) gdata::DownloadFileOperation overrides the default implementations
   //         of the following methods of net::URLFetcherDelegate:
   //         - ShouldSendDownloadData(): returns true for non-null
-  //                                     GetContentCallback.
+  //                                     gdata::GetContentCallback.
   //         - OnURLFetchDownloadData(): invokes non-null
-  //                                     GetContentCallback
+  //                                     gdata::GetContentCallback
   //    7.3) DriveProtolHandler::OnURLFetchDownloadData (i.e. this class)
   //         is at the end of the invocation chain and actually implements the
   //         method.
   //    7.4) Copies the formal download data into a growable-drainable download
   //         IOBuffer
   //         - IOBuffer has initial size 4096, same as buffer used in
   //           net::URLFetcherCore::OnReadCompleted.
   //         - We may end up with multiple chunks, so we use GrowableIOBuffer.
   //         - We then wrap the growable buffer within a DrainableIOBuffer for
   //           ease of progressively writing into the buffer.
@@ skipping 243 matching lines @@
   DVLOG(1) << "Getting file for resource id";
   file_system_->GetFileByResourceId(
       resource_id,
       base::Bind(&DriveURLRequestJob::OnGetFileByResourceId,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&DriveURLRequestJob::OnUrlFetchDownloadData,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void DriveURLRequestJob::OnUrlFetchDownloadData(
-    GDataErrorCode error,
+    gdata::GDataErrorCode error,
     scoped_ptr<std::string> download_data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (download_data->empty())
     return;
 
   // If there's insufficient space remaining in download buffer to copy download
   // data, expand download buffer.
   int bytes_needed = download_data->length() -
                      download_drainable_buf_->BytesRemaining();
@@ skipping 382 matching lines @@
 
 DriveProtocolHandler::~DriveProtocolHandler() {
 }
 
 net::URLRequestJob* DriveProtocolHandler::MaybeCreateJob(
     net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
   DVLOG(1) << "Handling url: " << request->url().spec();
   return new DriveURLRequestJob(request, network_delegate);
 }
 
-}  // namespace gdata
+}  // namespace drive