gdata: Move some static functions to anonymous namespace

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 <sys/stat.h>
 
 #include <set>
@@ skipping 668 matching lines @@
   upload_file_info->all_bytes_present = true;
   std::string mime_type;
   if (!net::GetMimeTypeFromExtension(local_file.Extension(),
                                      &upload_file_info->content_type)) {
     upload_file_info->content_type= kMimeTypeOctetStream;
   }
 
   *error = base::PLATFORM_FILE_OK;
 }
 
+// Checks if a local file at |local_file_path| is a JSON file referencing a
+// hosted document on IO thread poll, and if so, gets the resource ID of the
+// document.
+void GetDocumentResourceIdOnIOThreadPool(
+    const FilePath& local_file_path,
+    std::string* resource_id) {
+  DCHECK(resource_id);
+
+  if (DocumentEntry::HasHostedDocumentExtension(local_file_path)) {
+    std::string error;
+    DictionaryValue* dict_value = NULL;
+    JSONFileValueSerializer serializer(local_file_path);
+    scoped_ptr<Value> value(serializer.Deserialize(NULL, &error));
+    if (value.get() && value->GetAsDictionary(&dict_value))
+      dict_value->GetString("resource_id", resource_id);
+  }
+}
+
+// Creates a temporary JSON file representing a document with |edit_url|
+// and |resource_id| under |document_dir| on IO thread pool.
+void CreateDocumentJsonFileOnIOThreadPool(
+    const FilePath& document_dir,
+    const GURL& edit_url,
+    const std::string& resource_id,
+    base::PlatformFileError* error,
+    FilePath* temp_file_path,
+    std::string* mime_type,
+    GDataFileType* file_type) {
+  DCHECK(error);
+  DCHECK(temp_file_path);
+  DCHECK(mime_type);
+  DCHECK(file_type);
+
+  *error = base::PLATFORM_FILE_ERROR_FAILED;
+
+  if (file_util::CreateTemporaryFileInDir(document_dir, temp_file_path)) {
+    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_path, document_content.data(),
+                             document_size) == document_size) {
+      *error = base::PLATFORM_FILE_OK;
+    }
+  }
+
+  *mime_type = kMimeTypeJson;
+  *file_type = HOSTED_DOCUMENT;
+  if (*error != base::PLATFORM_FILE_OK)
+      temp_file_path->clear();
+}
+
 }  // namespace
 
 // FindEntryDelegate class implementation.
 
 FindEntryDelegate::~FindEntryDelegate() {
 }
 
 // FindEntryCallbackRelayDelegate class implementation.
 // This class is used to relay calls between sync and async versions
 // of FindFileByPath(Sync|Async) calls.
@@ skipping 427 matching lines @@
     base::MessageLoopProxy::current()->PostTask(FROM_HERE,
         base::Bind(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND));
     NOTREACHED();
     return;
   }
 
   std::string* resource_id = new std::string;
   PostBlockingPoolSequencedTaskAndReply(
       kGDataFileSystemToken,
       FROM_HERE,
-      base::Bind(&GDataFileSystem::GetDocumentResourceIdOnIOThreadPool,
+      base::Bind(&GetDocumentResourceIdOnIOThreadPool,
                  local_file_path,
                  resource_id),
       base::Bind(&GDataFileSystem::TransferFileForResourceId,
                  GetWeakPtrForCurrentThread(),
                  local_file_path,
                  remote_dest_file_path,
                  callback,
                  base::Owned(resource_id)));
 }
 
@@ skipping 39 matching lines @@
                  remote_dest_file_path,
                  error,
                  upload_file_info),
       base::Bind(&GDataFileSystem::StartFileUploadOnUIThread,
                  GetWeakPtrForCurrentThread(),
                  callback,
                  error,
                  upload_file_info));
 }
 
-// static
-void GDataFileSystem::GetDocumentResourceIdOnIOThreadPool(
-    const FilePath& local_file_path,
-    std::string* resource_id) {
-  DCHECK(resource_id);
-
-  if (DocumentEntry::HasHostedDocumentExtension(local_file_path)) {
-    std::string error;
-    DictionaryValue* dict_value = NULL;
-    JSONFileValueSerializer serializer(local_file_path);
-    scoped_ptr<Value> value(serializer.Deserialize(NULL, &error));
-    if (value.get() && value->GetAsDictionary(&dict_value))
-      dict_value->GetString("resource_id", resource_id);
-  }
-}
-
 void GDataFileSystem::StartFileUploadOnUIThread(
     const FileOperationCallback& callback,
     base::PlatformFileError* error,
     UploadFileInfo* upload_file_info) {
   // This method needs to run on the UI thread as required by
   // GDataUploader::UploadFile().
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(error);
   DCHECK(upload_file_info);
 
@@ skipping 406 matching lines @@
       base::Bind(&GDataFileSystem::OnCreateDirectoryCompleted,
                  GetWeakPtrForCurrentThread(),
                  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,
-    base::PlatformFileError* error,
-    FilePath* temp_file_path,
-    std::string* mime_type,
-    GDataFileType* file_type) {
-  DCHECK(error);
-  DCHECK(temp_file_path);
-  DCHECK(mime_type);
-  DCHECK(file_type);
-
-  *error = base::PLATFORM_FILE_ERROR_FAILED;
-
-  if (file_util::CreateTemporaryFileInDir(document_dir, temp_file_path)) {
-    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_path, document_content.data(),
-                             document_size) == document_size) {
-      *error = base::PLATFORM_FILE_OK;
-    }
-  }
-
-  *mime_type = kMimeTypeJson;
-  *file_type = HOSTED_DOCUMENT;
-  if (*error != base::PLATFORM_FILE_OK)
-      temp_file_path->clear();
-}
-
 void GDataFileSystem::GetFileByPath(const FilePath& file_path,
                                     const GetFileCallback& callback) {
   GDataFileProperties file_properties;
   if (!GetFileInfoByPath(file_path, &file_properties)) {
     if (!callback.is_null()) {
       MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(callback,
                      base::PLATFORM_FILE_ERROR_NOT_FOUND,
                      FilePath(),
@@ skipping 11 matching lines @@
     InitializeCacheIfNecessary();
 
     base::PlatformFileError* error =
         new base::PlatformFileError(base::PLATFORM_FILE_OK);
     FilePath* temp_file_path = new FilePath;
     std::string* mime_type = new std::string;
     GDataFileType* file_type = new GDataFileType(REGULAR_FILE);
     PostBlockingPoolSequencedTaskAndReply(
         kGDataFileSystemToken,
         FROM_HERE,
-        base::Bind(&GDataFileSystem::CreateDocumentJsonFileOnIOThreadPool,
+        base::Bind(&CreateDocumentJsonFileOnIOThreadPool,
                    GetCacheDirectoryPath(
                        GDataRootDirectory::CACHE_TYPE_TMP_DOCUMENTS),
                    file_properties.alternate_url,
                    file_properties.resource_id,
                    error,
                    temp_file_path,
                    mime_type,
                    file_type),
         base::Bind(&RunGetFileCallbackHelper,
                    callback,
@@ skipping 2684 matching lines @@
   pref_registrar_->Init(profile_->GetPrefs());
   pref_registrar_->Add(prefs::kDisableGDataHostedFiles, this);
 }
 
 void SetFreeDiskSpaceGetterForTesting(FreeDiskSpaceGetterInterface* getter) {
   delete global_free_disk_getter_for_testing;  // Safe to delete NULL;
   global_free_disk_getter_for_testing = getter;
 }
 
 }  // namespace gdata