Refactoring: replace SearchInDirectory by SearchByTitle.

chrome/browser/sync_file_system/drive_file_sync_client.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/sync_file_system/drive_file_sync_client.h"
 
 #include <algorithm>
 #include <functional>
 #include <sstream>
 #include <string>
@@ skipping 167 matching lines @@
   DCHECK(CalledOnValidThread());
   observers_.RemoveObserver(observer);
 }
 
 void DriveFileSyncClient::GetDriveDirectoryForSyncRoot(
     const ResourceIdCallback& callback) {
   DCHECK(CalledOnValidThread());
   DVLOG(2) << "Getting Drive directory for SyncRoot";
 
   std::string directory_name(kSyncRootDirectoryName);
-  drive_service_->Search(
-      FormatTitleQuery(directory_name),
-      base::Bind(&DriveFileSyncClient::DidGetResourceList, AsWeakPtr(),
-                 base::Bind(&DriveFileSyncClient::DidGetDirectory, AsWeakPtr(),
-                            std::string(), directory_name, callback)));
+  SearchByTitle(directory_name, "",

[tzik, 2013/04/18 14:26:23]

s/""/std::string()/ ?

[hidehiko, 2013/04/22 04:24:45]

Done.

+                base::Bind(&DriveFileSyncClient::DidGetDirectory, AsWeakPtr(),
+                           std::string(), directory_name, callback));
 }
 
 void DriveFileSyncClient::GetDriveDirectoryForOrigin(
     const std::string& sync_root_resource_id,
     const GURL& origin,
     const ResourceIdCallback& callback) {
   DCHECK(CalledOnValidThread());
   DVLOG(2) << "Getting Drive directory for Origin: " << origin;
 
   std::string directory_name(OriginToDirectoryTitle(origin));
-  SearchFilesInDirectory(
-      sync_root_resource_id,
-      FormatTitleQuery(directory_name),
+  SearchByTitle(
+      directory_name, sync_root_resource_id,
       base::Bind(&DriveFileSyncClient::DidGetDirectory, AsWeakPtr(),
                  sync_root_resource_id, directory_name, callback));
 }
 
 void DriveFileSyncClient::DidGetDirectory(
     const std::string& parent_resource_id,
     const std::string& directory_name,
     const ResourceIdCallback& callback,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::ResourceList> feed) {
@@ skipping 129 matching lines @@
     DCHECK(about_resource);
     largest_change_id = about_resource->largest_change_id();
     DVLOG(2) << "Got largest change id: " << largest_change_id;
   } else {
     DVLOG(2) << "Error on getting largest change id: " << error;
   }
 
   callback.Run(error, largest_change_id);
 }
 
-void DriveFileSyncClient::SearchFilesInDirectory(
+void DriveFileSyncClient::SearchByTitle(
+    const std::string& title,
     const std::string& directory_resource_id,
-    const std::string& search_query,
     const ResourceListCallback& callback) {
   DCHECK(CalledOnValidThread());
-  DCHECK(!directory_resource_id.empty());
+  DCHECK(!title.empty());
   DVLOG(2) << "Searching resources in the directory [" << directory_resource_id
-           << "] with query [" << search_query << "]";
+           << "] with title [" << title << "]";
 
-  drive_service_->SearchInDirectory(
-      search_query,
+  drive_service_->SearchByTitle(
+      title,
       directory_resource_id,
       base::Bind(&DriveFileSyncClient::DidGetResourceList,
                  AsWeakPtr(), callback));
 }
 
 void DriveFileSyncClient::ListFiles(const std::string& directory_resource_id,
                                     const ResourceListCallback& callback) {
   DCHECK(CalledOnValidThread());
   DVLOG(2) << "Listing resources in the directory ["
            << directory_resource_id << "]";
@@ skipping 187 matching lines @@
     DVLOG(2) << "Error on getting resource entry:" << error;
     callback.Run(error, scoped_ptr<google_apis::ResourceEntry>());
     return;
   }
 
   DVLOG(2) << "Got resource entry";
   DCHECK(entry);
   callback.Run(error, entry.Pass());
 }
 
-// static
-std::string DriveFileSyncClient::FormatTitleQuery(const std::string& title) {
-  // TODO(tzik): This pattern matches partial and case-insensitive,
-  // and also matches files in subdirectories.
-  // Refine the query after we migrate to Drive API.
-  std::ostringstream out;
-  out << "title:";
-
-  // Escape single quote and back slash with '\\'.
-  // https://developers.google.com/drive/search-parameters
-  out << '\'';
-  for (std::string::const_iterator itr = title.begin();
-       itr != title.end(); ++itr) {
-    switch (*itr) {
-      case '\'':
-      case '\\':
-        out << '\\' << *itr;
-        break;
-      default:
-        out << *itr;
-        break;
-    }
-  }
-  out << '\'';
-  return out.str();
-}
-
 void DriveFileSyncClient::DownloadFileInternal(
     const std::string& local_file_md5,
     const base::FilePath& local_file_path,
     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";
@@ skipping 202 matching lines @@
     const std::string& parent_resource_id,
     const std::string& expected_title,
     const ResourceEntryCallback& callback) {
   DCHECK(CalledOnValidThread());
   DVLOG(2) << "Checking if there's no conflict on entry creation";
 
   const google_apis::GetResourceListCallback& bound_callback =
       base::Bind(&DriveFileSyncClient::DidListEntriesToEnsureUniqueness,
                  AsWeakPtr(), parent_resource_id, expected_title, callback);
 
-  if (parent_resource_id.empty()) {
-    // Here, it is a part of process to create a sync root directory.
-    // The sync root directory may be orphan or be under mydrive directory,
-    // due to historical reason. So, it is necessary to search both just orphan
-    // resources and ones under mydrive.
-    // Unfortunately there is no way to search only from orphan resources,
-    // so here search all the resources. Unreleated results will be filtered
-    // out below.
-    drive_service_->Search(
-        FormatTitleQuery(expected_title),
-        base::Bind(&DriveFileSyncClient::DidGetResourceList, AsWeakPtr(),
-                   bound_callback));
-  } else {
-    SearchFilesInDirectory(
-        parent_resource_id,
-        FormatTitleQuery(expected_title),
-        bound_callback);
-  }
+  SearchByTitle(expected_title, parent_resource_id, bound_callback);
 }
 
 void DriveFileSyncClient::DidListEntriesToEnsureUniqueness(
     const std::string& parent_resource_id,
     const std::string& expected_title,
     const ResourceEntryCallback& callback,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::ResourceList> feed) {
   DCHECK(CalledOnValidThread());
   if (error != google_apis::HTTP_SUCCESS) {
@@ skipping 119 matching lines @@
     return;
   for (UploadCallbackMap::iterator iter = upload_callback_map_.begin();
        iter != upload_callback_map_.end(); ++iter) {
     iter->second.Run(error, std::string(), std::string());
   }
   upload_callback_map_.clear();
   drive_uploader_.reset(new google_apis::DriveUploader(drive_service_.get()));
 }
 
 }  // namespace sync_file_system