gdata: Fix issue with copying hosted documents out from Docs folder.

chrome/browser/chromeos/gdata/gdata_file_system.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_file_system.h"
 
 #include <errno.h>
 
 #include <utility>
 
@@ skipping 35 matching lines @@
 const FilePath::CharType kGDataCacheVersionDir[] = FILE_PATH_LITERAL("v1");
 const FilePath::CharType kGDataCacheMetaDir[] = FILE_PATH_LITERAL("meta");
 const FilePath::CharType kGDataCachePinnedDir[] = FILE_PATH_LITERAL("pinned");
 const FilePath::CharType kGDataCacheOutgoingDir[] =
     FILE_PATH_LITERAL("outgoing");
 const FilePath::CharType kGDataCachePersistentDir[] =
     FILE_PATH_LITERAL("persistent");
 const FilePath::CharType kGDataCacheTmpDir[] = FILE_PATH_LITERAL("tmp");
 const FilePath::CharType kGDataCacheTmpDownloadsDir[] =
     FILE_PATH_LITERAL("tmp/downloads");
+const FilePath::CharType kGDataCacheTmpDocumentsDir[] =
+    FILE_PATH_LITERAL("tmp/documents");
 const FilePath::CharType kLastFeedFile[] = FILE_PATH_LITERAL("last_feed.json");
 const char kGDataFileSystemToken[] = "GDataFileSystemToken";
 const FilePath::CharType kAccountMetadataFile[] =
     FILE_PATH_LITERAL("account_metadata.json");
 const FilePath::CharType kSymLinkToDevNull[] = FILE_PATH_LITERAL("/dev/null");
 
 // Converts gdata error code into file platform error code.
 base::PlatformFileError GDataToPlatformError(gdata::GDataErrorCode status) {
   switch (status) {
     case gdata::HTTP_SUCCESS:
@@ skipping 353 matching lines @@
   chrome::GetUserCacheDirectory(profile_->GetPath(), &cache_base_path);
   gdata_cache_path_ = cache_base_path.Append(chrome::kGDataCacheDirname);
   gdata_cache_path_ = gdata_cache_path_.Append(kGDataCacheVersionDir);
   // Insert into |cache_paths_| in order defined in enum CacheSubDirectoryType.
   cache_paths_.push_back(gdata_cache_path_.Append(kGDataCacheMetaDir));
   cache_paths_.push_back(gdata_cache_path_.Append(kGDataCachePinnedDir));
   cache_paths_.push_back(gdata_cache_path_.Append(kGDataCacheOutgoingDir));
   cache_paths_.push_back(gdata_cache_path_.Append(kGDataCachePersistentDir));
   cache_paths_.push_back(gdata_cache_path_.Append(kGDataCacheTmpDir));
   cache_paths_.push_back(gdata_cache_path_.Append(kGDataCacheTmpDownloadsDir));
+  cache_paths_.push_back(gdata_cache_path_.Append(kGDataCacheTmpDocumentsDir));
 
   documents_service_->Initialize(profile_);
 
   root_.reset(new GDataRootDirectory(this));
   root_->set_file_name(kGDataRootDirectory);
 }
 
 GDataFileSystem::~GDataFileSystem() {
   // Should be deleted on IO thread by GDataSystemService.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ skipping 533 matching lines @@
                  CreateDirectoryParams(
                      first_missing_path,
                      directory_path,
                      is_exclusive,
                      is_recursive,
                      callback)));
 }
 
 // static
 void GDataFileSystem::CreateDocumentJsonFileOnIOThreadPool(
+    const FilePath& document_dir,
     const GURL& edit_url,
     const std::string& resource_id,
     const GetFileCallback& callback,
     scoped_refptr<base::MessageLoopProxy> relay_proxy) {
   base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
   FilePath temp_file;
 
-  if (file_util::CreateTemporaryFile(&temp_file)) {
+  if (file_util::CreateTemporaryFileInDir(document_dir, &temp_file)) {
     std::string document_content = base::StringPrintf(
         "{\"url\": \"%s\", \"resource_id\": \"%s\"}",
         edit_url.spec().c_str(), resource_id.c_str());
     int document_size = static_cast<int>(document_content.size());
     if (file_util::WriteFile(temp_file, document_content.data(),
                              document_size) == document_size) {
       error = base::PLATFORM_FILE_OK;
     }
   }
 
@@ skipping 19 matching lines @@
                      REGULAR_FILE));
     }
     return;
   }
 
   // For a hosted document, we create a special JSON file to represent the
   // document instead of fetching the document content in one of the exported
   // formats. The JSON file contains the edit URL and resource ID of the
   // document.
   if (file_properties.is_hosted_document) {
-    BrowserThread::PostBlockingPoolTask(FROM_HERE,
+    InitializeCacheIfNecessary();
+
+    PostBlockingPoolSequencedTask(
+        kGDataFileSystemToken,
+        FROM_HERE,
         base::Bind(&GDataFileSystem::CreateDocumentJsonFileOnIOThreadPool,
+                   GetGDataTempDocumentFolderPath(),
                    file_properties.edit_url,
                    file_properties.resource_id,
                    callback,
                    base::MessageLoopProxy::current()));
     return;
   }
 
   // Returns absolute path of the file if it were cached or to be cached.
   FilePath local_tmp_path = GetCacheFilePath(file_properties.resource_id,
                                              file_properties.file_md5,
@@ skipping 228 matching lines @@
 }
 
 FilePath GDataFileSystem::GetGDataCacheTmpDirectory() const {
   return cache_paths_[GDataRootDirectory::CACHE_TYPE_TMP];
 }
 
 FilePath GDataFileSystem::GetGDataTempDownloadFolderPath() const {
   return cache_paths_[GDataRootDirectory::CACHE_TYPE_TMP_DOWNLOADS];
 }
 
+FilePath GDataFileSystem::GetGDataTempDocumentFolderPath() const {
+  return cache_paths_[GDataRootDirectory::CACHE_TYPE_TMP_DOCUMENTS];
+}
+
 FilePath GDataFileSystem::GetGDataCachePinnedDirectory() const {
   return cache_paths_[GDataRootDirectory::CACHE_TYPE_PINNED];
 }
 
 FilePath GDataFileSystem::GetGDataCachePersistentDirectory() const {
   return cache_paths_[GDataRootDirectory::CACHE_TYPE_PERSISTENT];
 }
 
 base::WeakPtr<GDataFileSystem> GDataFileSystem::GetWeakPtrForCurrentThread() {
   if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
@@ skipping 2073 matching lines @@
   const bool posted = BrowserThread::PostBlockingPoolSequencedTask(
       sequence_token_name,
       from_here,
       base::Bind(&GDataFileSystem::RunTaskOnIOThreadPool,
                  base::Unretained(this),
                  task));
   DCHECK(posted);
 }
 
 }  // namespace gdata