Remove gdata:: from gdata_file_system_proxy.cc and .h

chrome/browser/chromeos/gdata/gdata_file_system_proxy.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_proxy.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 32 matching lines @@
                                 base::PlatformFileError* open_error) {
   bool created;
   *platform_file = base::CreatePlatformFile(local_path,
                                             file_flags,
                                             &created,
                                             open_error);
 }
 
 // Helper function to run reply on results of OpenPlatformFileOnIOPool() on
 // IO thread.
 void OnPlatformFileOpened(

[kochi, 2012/08/08 10:59:38]

Can you move these top-level functions into
gdata::{} namespace?  If these functions are not used
elsewhere outside this file, it should be possible to remove
more gdata:: prefixes.

[Haruki Sato, 2012/08/09 04:22:04]

Done.
Thank you for the helpful adivce.
It is actually possible everywhere!

     const FileSystemOperationInterface::OpenFileCallback& callback,
     base::ProcessHandle peer_handle,
     base::PlatformFile* platform_file,
     base::PlatformFileError* open_error) {
   callback.Run(*open_error, *platform_file, peer_handle);
 }
 
 // Helper function to run OpenFileCallback from
 // GDataFileSystemProxy::OpenFile().
 void OnGetFileByPathForOpen(
@@ skipping 295 matching lines @@
 
 void GDataFileSystemProxy::OnOpenFileForWriting(
     int file_flags,
     base::ProcessHandle peer_handle,
     const FileSystemOperationInterface::OpenFileCallback& callback,
     GDataFileError gdata_error,
     const FilePath& local_cache_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   base::PlatformFileError error =
-      gdata::util::GDataFileErrorToPlatformError(gdata_error);
+      util::GDataFileErrorToPlatformError(gdata_error);
 
   if (error != base::PLATFORM_FILE_OK) {
     callback.Run(error, base::kInvalidPlatformFileValue, peer_handle);
     return;
   }
 
   // Cache file prepared for modification is available. Truncate it.
   // File operation must be done on FILE thread, so relay the operation.
   base::PlatformFileError* result =
       new base::PlatformFileError(base::PLATFORM_FILE_ERROR_FAILED);
@@ skipping 14 matching lines @@
 }
 
 void GDataFileSystemProxy::OnCreateFileForOpen(
     const FilePath& file_path,
     int file_flags,
     base::ProcessHandle peer_handle,
     const FileSystemOperationInterface::OpenFileCallback& callback,
     GDataFileError gdata_error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   base::PlatformFileError create_result =
-      gdata::util::GDataFileErrorToPlatformError(gdata_error);
+      util::GDataFileErrorToPlatformError(gdata_error);
 
   if ((create_result == base::PLATFORM_FILE_OK) ||
       ((create_result == base::PLATFORM_FILE_ERROR_EXISTS) &&
        (file_flags & base::PLATFORM_FILE_CREATE_ALWAYS))) {
     // If we are trying to always create an existing file, then
     // if it really exists open it as truncated.
     file_flags &= ~base::PLATFORM_FILE_CREATE;
     file_flags &= ~base::PLATFORM_FILE_CREATE_ALWAYS;
     file_flags |= base::PLATFORM_FILE_OPEN_TRUNCATED;
   } else {
@@ skipping 228 matching lines @@
   // what platform you're on.
   if (!url.is_valid() || url.type() != fileapi::kFileSystemTypeExternal) {
     return false;
   }
   *file_path = url.path();
   return true;
 }
 
 void GDataFileSystemProxy::OnStatusCallback(
     const fileapi::FileSystemOperationInterface::StatusCallback& callback,
-    gdata::GDataFileError error) {
+    GDataFileError error) {
   callback.Run(util::GDataFileErrorToPlatformError(error));
 }
 
 void GDataFileSystemProxy::OnGetMetadata(
     const FilePath& file_path,
     const FileSystemOperationInterface::GetMetadataCallback& callback,
     GDataFileError error,
-    scoped_ptr<gdata::GDataEntryProto> entry_proto) {
+    scoped_ptr<GDataEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (error != GDATA_FILE_OK) {
     callback.Run(util::GDataFileErrorToPlatformError(error),
                  base::PlatformFileInfo(),
                  FilePath());
     return;
   }
   DCHECK(entry_proto.get());
 
   base::PlatformFileInfo file_info;
   GDataEntry::ConvertProtoToPlatformFileInfo(
       entry_proto->file_info(),
       &file_info);
 
   callback.Run(base::PLATFORM_FILE_OK, file_info, file_path);
 }
 
 void GDataFileSystemProxy::OnReadDirectory(
     const FileSystemOperationInterface::ReadDirectoryCallback&
     callback,
     GDataFileError error,
-    scoped_ptr<gdata::GDataEntryProtoVector> proto_entries) {
+    scoped_ptr<GDataEntryProtoVector> proto_entries) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   PrefService* pref_service = profile_->GetPrefs();
   const bool hide_hosted_documents =
       pref_service->GetBoolean(prefs::kDisableGDataHostedFiles);
 
   if (error != GDATA_FILE_OK) {
     callback.Run(util::GDataFileErrorToPlatformError(error),
                  std::vector<base::FileUtilProxy::Entry>(),
                  false);
@@ skipping 42 matching lines @@
 
 void GDataFileSystemProxy::CloseWritableSnapshotFile(
     const FilePath& virtual_path,
     const FilePath& local_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   file_system_->CloseFile(virtual_path, base::Bind(&OnClose, virtual_path));
 }
 
 }  // namespace gdata