Rename GDataErrorCode to DriveErrorCode, GDataFileError to DriveFileError

chrome/browser/chromeos/gdata/gdata_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/gdata/gdata_protocol_handler.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/gdata/drive.pb.h"
+#include "chrome/browser/chromeos/gdata/drive_errorcode.h"
 #include "chrome/browser/chromeos/gdata/drive_service_interface.h"
-#include "chrome/browser/chromeos/gdata/gdata_errorcode.h"
 #include "chrome/browser/chromeos/gdata/gdata_file_system_interface.h"
 #include "chrome/browser/chromeos/gdata/gdata_system_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/escape.h"
 #include "net/base/file_stream.h"
 #include "net/base/net_errors.h"
@@ skipping 114 matching lines @@
 
  private:
   // Helper for Start() to let us start asynchronously.
   void StartAsync(GDataFileSystemInterface** 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(DriveErrorCode 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
   // GDataFileSystem::GetFileByResourceId().
-  void OnGetFileByResourceId(GDataFileError error,
+  void OnGetFileByResourceId(DriveFileError error,
                              const FilePath& local_file_path,
                              const std::string& mime_type,
                              DriveFileType file_type);
 
   // Helper callback for GetFileSizeOnBlockingPool that sets |remaining_bytes_|
   // to |file_size|, and notifies result for Start().
   void OnGetFileSize(int64 *file_size);
 
   // Helper callback for GetEntryInfoByResourceId invoked by StartAsync.
   void OnGetEntryInfoByResourceId(const std::string& resource_id,
-                                  GDataFileError error,
+                                  DriveFileError error,
                                   const FilePath& gdata_file_path,
                                   scoped_ptr<DriveEntryProto> entry_proto);
 
   // Helper methods for ReadRawData to open file and read from its corresponding
   // stream in a streaming fashion.
   bool ContinueReadFromFile(int* bytes_read);
   void ReadFromFile();
   void ReadFileStream(int bytes_to_read);
 
   // Helper callback for handling async responses from FileStream::Open().
@@ skipping 313 matching lines @@
 
   file_system_->GetEntryInfoByResourceId(
       resource_id,
       base::Bind(&GDataURLRequestJob::OnGetEntryInfoByResourceId,
                  weak_ptr_factory_->GetWeakPtr(),
                  resource_id));
 }
 
 void GDataURLRequestJob::OnGetEntryInfoByResourceId(
     const std::string& resource_id,
-    GDataFileError error,
+    DriveFileError error,
     const FilePath& gdata_file_path,
     scoped_ptr<DriveEntryProto> entry_proto) {
   if (entry_proto.get() && !entry_proto->has_file_specific_info())
-    error = GDATA_FILE_ERROR_NOT_FOUND;
+    error = DRIVE_FILE_ERROR_NOT_FOUND;
 
-  if (error == GDATA_FILE_OK) {
+  if (error == DRIVE_FILE_OK) {
     DCHECK(entry_proto.get());
     mime_type_ = entry_proto->file_specific_info().content_mime_type();
     gdata_file_path_ = gdata_file_path;
     initial_file_size_ = entry_proto->file_info().size();
   } else {
     mime_type_.clear();
     gdata_file_path_.clear();
     initial_file_size_ = 0;
   }
   remaining_bytes_ = initial_file_size_;
 
   DVLOG(1) << "Getting file for resource id";
   file_system_->GetFileByResourceId(
       resource_id,
       base::Bind(&GDataURLRequestJob::OnGetFileByResourceId,
                  weak_ptr_factory_->GetWeakPtr()),
       base::Bind(&GDataURLRequestJob::OnUrlFetchDownloadData,
                  weak_ptr_factory_->GetWeakPtr()));
 }
 
 void GDataURLRequestJob::OnUrlFetchDownloadData(
-    GDataErrorCode error,
+    DriveErrorCode 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 97 matching lines @@
     // Set offset in download buffer to where we finished moving.
     download_drainable_buf_->SetOffset(bytes_not_copied);
   }
   DVLOG(1) << "Copied from download data: bytes_read=" << bytes_to_read;
 
   // Return true if read buffer is filled up or there's no more bytes to read.
   return read_buf_->BytesRemaining() == 0 || remaining_bytes_ == 0;
 }
 
 void GDataURLRequestJob::OnGetFileByResourceId(
-    GDataFileError error,
+    DriveFileError error,
     const FilePath& local_file_path,
     const std::string& mime_type,
     DriveFileType file_type) {
   DVLOG(1) << "Got OnGetFileByResourceId";
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  if (error != GDATA_FILE_OK || file_type != REGULAR_FILE) {
+  if (error != DRIVE_FILE_OK || file_type != REGULAR_FILE) {
     LOG(WARNING) << "Failed to start request: can't get file for resource id";
     NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                            net::ERR_FILE_NOT_FOUND));
     return;
   }
 
   local_file_path_ = local_file_path;
 
   // If we've already streamed download data to response, we're done.
   if (streaming_download_)
@@ skipping 258 matching lines @@
 GDataProtocolHandler::~GDataProtocolHandler() {
 }
 
 net::URLRequestJob* GDataProtocolHandler::MaybeCreateJob(
     net::URLRequest* request) const {
   DVLOG(1) << "Handling url: " << request->url().spec();
   return new GDataURLRequestJob(request);
 }
 
 }  // namespace gdata