Move storage-related files from webkit/ to new top-level directory storage/

chrome/browser/sync_file_system/drive_backend_v1/api_util.cc

 // Copyright 2013 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/sync_file_system/drive_backend_v1/api_util.h"
 
 #include <algorithm>
 #include <functional>
 #include <sstream>
 #include <string>
@@ skipping 125 matching lines @@
   base::FilePath::StringType extension =
       base::FilePath::FromUTF8Unsafe(title).Extension();
   std::string mime_type;
   if (extension.empty() ||
       !net::GetWellKnownMimeTypeFromExtension(extension.substr(1), &mime_type))
     return kMimeTypeOctetStream;
   return mime_type;
 }
 
 bool CreateTemporaryFile(const base::FilePath& dir_path,
-                         webkit_blob::ScopedFile* temp_file) {
+                         storage::ScopedFile* temp_file) {
   base::FilePath temp_file_path;
   const bool success = base::CreateDirectory(dir_path) &&
       base::CreateTemporaryFileInDir(dir_path, &temp_file_path);
   if (!success)
     return success;
-  *temp_file =
-      webkit_blob::ScopedFile(temp_file_path,
-                              webkit_blob::ScopedFile::DELETE_ON_SCOPE_OUT,
-                              base::ThreadTaskRunnerHandle::Get().get());
+  *temp_file = storage::ScopedFile(temp_file_path,
+                                   storage::ScopedFile::DELETE_ON_SCOPE_OUT,
+                                   base::ThreadTaskRunnerHandle::Get().get());
   return success;
 }
 
 }  // namespace
 
 APIUtil::APIUtil(Profile* profile,
                  const base::FilePath& temp_dir_path)
     : oauth_service_(ProfileOAuth2TokenServiceFactory::GetForProfile(profile)),
       signin_manager_(SigninManagerFactory::GetForProfile(profile)),
       upload_next_key_(0),
@@ skipping 332 matching lines @@
       base::Bind(&APIUtil::DidGetFileList, AsWeakPtr(), callback));
 }
 
 void APIUtil::DownloadFile(const std::string& resource_id,
                            const std::string& local_file_md5,
                            const DownloadFileCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!temp_dir_path_.empty());
   DVLOG(2) << "Downloading file [" << resource_id << "]";
 
-  scoped_ptr<webkit_blob::ScopedFile> temp_file(new webkit_blob::ScopedFile);
-  webkit_blob::ScopedFile* temp_file_ptr = temp_file.get();
+  scoped_ptr<storage::ScopedFile> temp_file(new storage::ScopedFile);
+  storage::ScopedFile* temp_file_ptr = temp_file.get();
   content::BrowserThread::PostTaskAndReplyWithResult(
       content::BrowserThread::FILE, FROM_HERE,
       base::Bind(&CreateTemporaryFile, temp_dir_path_, temp_file_ptr),
       base::Bind(&APIUtil::DidGetTemporaryFileForDownload,
                  AsWeakPtr(), resource_id, local_file_md5,
                  base::Passed(&temp_file), callback));
 }
 
 void APIUtil::UploadNewFile(const std::string& directory_resource_id,
                             const base::FilePath& local_file_path,
@@ skipping 211 matching lines @@
     return;
   }
 
   DVLOG(2) << "Got resource entry";
   callback.Run(error, drive::util::ConvertFileResourceToResourceEntry(*entry));
 }
 
 void APIUtil::DidGetTemporaryFileForDownload(
     const std::string& resource_id,
     const std::string& local_file_md5,
-    scoped_ptr<webkit_blob::ScopedFile> local_file,
+    scoped_ptr<storage::ScopedFile> local_file,
     const DownloadFileCallback& callback,
     bool success) {
   if (!success) {
     DVLOG(2) << "Error in creating a temp file under "
              << temp_dir_path_.value();
     callback.Run(google_apis::GDATA_FILE_ERROR, std::string(), 0, base::Time(),
                  local_file->Pass());
     return;
   }
   drive_service_->GetFileResource(
       resource_id,
       base::Bind(&APIUtil::DidGetFileResource,
                  AsWeakPtr(),
                  base::Bind(&APIUtil::DownloadFileInternal,
                             AsWeakPtr(),
                             local_file_md5,
                             base::Passed(&local_file),
                             callback)));
 }
 
 void APIUtil::DownloadFileInternal(
     const std::string& local_file_md5,
-    scoped_ptr<webkit_blob::ScopedFile> local_file,
+    scoped_ptr<storage::ScopedFile> local_file,
     const DownloadFileCallback& callback,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::ResourceEntry> entry) {
   DCHECK(CalledOnValidThread());
 
   if (error != google_apis::HTTP_SUCCESS) {
     DVLOG(2) << "Error on getting resource entry for download";
     callback.Run(error, std::string(), 0, base::Time(), local_file->Pass());
     return;
   }
@@ skipping 18 matching lines @@
                                base::Bind(&APIUtil::DidDownloadFile,
                                           AsWeakPtr(),
                                           base::Passed(&entry),
                                           base::Passed(&local_file),
                                           callback),
                                google_apis::GetContentCallback(),
                                google_apis::ProgressCallback());
 }
 
 void APIUtil::DidDownloadFile(scoped_ptr<google_apis::ResourceEntry> entry,
-                              scoped_ptr<webkit_blob::ScopedFile> local_file,
+                              scoped_ptr<storage::ScopedFile> local_file,
                               const DownloadFileCallback& callback,
                               google_apis::GDataErrorCode error,
                               const base::FilePath& downloaded_file_path) {
   DCHECK(CalledOnValidThread());
   if (error == google_apis::HTTP_SUCCESS)
     DVLOG(2) << "Download completed";
   else
     DVLOG(2) << "Error on downloading file: " << error;
 
   callback.Run(
@@ skipping 329 matching lines @@
 }
 
 std::string APIUtil::GetRootResourceId() const {
   if (IsDriveAPIDisabled())
     return drive_service_->GetRootResourceId();
   return root_resource_id_;
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system