Add gdata content search

chrome/browser/chromeos/gdata/gdata_file_system.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILE_SYSTEM_H_
 #define CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILE_SYSTEM_H_
 #pragma once
 
 #include <sys/stat.h>
 
@@ skipping 323 matching lines @@
                                       const GetFileInfoCallback& callback) = 0;
 
   // Finds and reads a directory by |file_path|. This call will also retrieve
   // and refresh file system content from server and disk cache.
   //
   // Can be called from UI/IO thread. |callback| is run on the calling thread.
   virtual void ReadDirectoryByPathAsync(
       const FilePath& file_path,
       const ReadDirectoryCallback& callback) = 0;
 
+  // Does server side content search for |search_query|. Search results will be
+  // returned as gdata entries in temp directory proto, and their
+  // title/file_name will be formatted as |<resource_id>.<original_file_name>|.
+  //
+  // Can be called from UI/IO thread. |callback| is run on the calling thread.
+  virtual void SearchAsync(const std::string& search_query,
+                           const ReadDirectoryCallback& callback) = 0;
+
+
   // Finds a file (not a directory) by |file_path| and returns its key
   // |properties|.  Returns true if file was found.
   // TODO(satorux): Remove this: crosbug.com/30066.
   virtual bool GetFileInfoByPath(const FilePath& file_path,
                                  GDataFileProperties* properties) = 0;
 
   // Returns true if the given path is under gdata cache directory, i.e.
   // <user_profile_dir>/GCache/v1
   virtual bool IsUnderGDataCacheDirectory(const FilePath& path) const = 0;
 
@@ skipping 42 matching lines @@
                   DocumentsServiceInterface* documents_service);
   virtual ~GDataFileSystem();
 
   // GDataFileSystem overrides.
   virtual void Initialize() OVERRIDE;
   virtual void AddObserver(Observer* observer) OVERRIDE;
   virtual void RemoveObserver(Observer* observer) OVERRIDE;
   virtual void Authenticate(const AuthStatusCallback& callback) OVERRIDE;
   virtual void FindEntryByResourceIdSync(const std::string& resource_id,
                                          FindEntryDelegate* delegate) OVERRIDE;
+  virtual void SearchAsync(const std::string& search_query,
+                           const ReadDirectoryCallback& callback) OVERRIDE;
   virtual void TransferFile(const FilePath& local_file_path,
                             const FilePath& remote_dest_file_path,
                             const FileOperationCallback& callback) OVERRIDE;
   virtual void Copy(const FilePath& src_file_path,
                     const FilePath& dest_file_path,
                     const FileOperationCallback& callback) OVERRIDE;
   virtual void Move(const FilePath& src_file_path,
                     const FilePath& dest_file_path,
                     const FileOperationCallback& callback) OVERRIDE;
   virtual void Remove(const FilePath& file_path,
@@ skipping 124 matching lines @@
     std::string mime_type;
     const GetFileCallback get_file_callback;
     const GetDownloadDataCallback get_download_data_callback;
   };
 
   // Defines set of parameters sent to callback OnGetDocuments().
   struct GetDocumentsParams {
     GetDocumentsParams(int start_changestamp,
                        int root_feed_changestamp,
                        std::vector<DocumentFeed*>* feed_list,
+                       bool should_fetch_multiple_feeds,
                        const FilePath& search_file_path,
+                       const std::string& search_query,
                        const FindEntryCallback& callback);
     ~GetDocumentsParams();
 
     // Changestamps are positive numbers in increasing order. The difference
     // between two changestamps is proportional equal to number of items in
     // delta feed between them - bigger the difference, more likely bigger
     // number of items in delta feeds.
     int start_changestamp;
     int root_feed_changestamp;
     scoped_ptr<std::vector<DocumentFeed*> > feed_list;
+    // Should we stop after getting first feed chunk, even if there is more
+    // data.
+    bool should_fetch_multiple_feeds;
     FilePath search_file_path;
+    std::string search_query;
     FindEntryCallback callback;
   };
 
   typedef std::map<std::string /* resource_id */, GDataEntry*>
       FileResourceIdMap;
 
   // Callback similar to FileOperationCallback but with a given |file_path|.
   typedef base::Callback<void(base::PlatformFileError error,
                               const FilePath& file_path)>
       FilePathUpdateCallback;
 
+  // Callback run as a response to LoadFeedFromServer.
+  typedef base::Callback<void(GetDocumentsParams* params,
+                              base::PlatformFileError error)>
+      LoadDocumentFeedCallback;
+
   // Finds entry object by |file_path| and returns the entry object.
   // Returns NULL if it does not find the entry.
   GDataEntry* GetGDataEntryByPath(const FilePath& file_path);
 
   // Inits cache directory paths in the provided root.
   // Should be called before cache is initialized.
   void SetCachePaths(const FilePath& root_path);
 
   // Initiates upload operation of file defined with |file_name|,
   // |content_type| and |content_length|. The operation will place the newly
@@ skipping 14 matching lines @@
   // TODO(satorux,achuith): Remove this: crosbug.com/29943
   void ResumeUpload(const ResumeUploadParams& params,
                     const ResumeFileUploadCallback& callback);
 
   // Converts document feed from gdata service into DirectoryInfo. On failure,
   // returns NULL and fills in |error| with an appropriate value.
   GDataDirectory* ParseGDataFeed(GDataErrorCode status,
                                  base::Value* data,
                                  base::PlatformFileError *error);
 
+  // Callback passed to |LoadFeedFromServer| from |SearchAsync| method.
+  // |callback| is that should be run with data received from
+  // |LoadFeedFromServer|.
+  // |params| params used for getting document feed for content search.
+  // |error| error code returned by |LoadFeedFromServer|.
+  void OnSearch(const ReadDirectoryCallback& callback,
+                GetDocumentsParams* params,
+                base::PlatformFileError error);
+
   // Initiates transfer of |local_file_path| with |resource_id| to
   // |remote_dest_file_path|. |local_file_path| must be a file from the local
   // file system, |remote_dest_file_path| is the virtual destination path within
   // gdata file system. If |resource_id| is a non-empty string, the transfer is
   // handled by CopyDocumentToDirectory. Otherwise, the transfer is handled by
   // TransferRegularFile.
   //
   // Must be called from *UI* thread. |callback| is run on the calling thread.
   void TransferFileForResourceId(const FilePath& local_file_path,
                                  const FilePath& remote_dest_file_path,
@@ skipping 55 matching lines @@
                                 base::PlatformFileError error,
                                 const FilePath& file_path);
 
   // Removes file under |file_path| from in-memory snapshot of the file system.
   // |resource_id| contains the resource id of the removed file if it was a
   // file.
   // Return PLATFORM_FILE_OK if successful.
   base::PlatformFileError RemoveEntryFromGData(const FilePath& file_path,
                                               std::string* resource_id);
 
-  // Callback for handling feed content fetching while searching for file info.
-  // This callback is invoked after async feed fetch operation that was
-  // invoked by StartDirectoryRefresh() completes. This callback will update
-  // the content of the refreshed directory object and continue initially
-  // started FindEntryByPath() request.
-  void OnGetDocuments(GetDocumentsParams* params,
+  // Callback for handling response from |GDataDocumentsService::GetDocuments|.
+  // Invokes |callback| when done.
+  void OnGetDocuments(const LoadDocumentFeedCallback& callback,
+                      GetDocumentsParams* params,
                       GDataErrorCode status,
                       scoped_ptr<base::Value> data);
 
   // A pass-through callback used for bridging from
   // FilePathUpdateCallback to FileOperationCallback.
   void OnFilePathUpdated(const FileOperationCallback& cllback,
                          base::PlatformFileError error,
                          const FilePath& file_path);
 
   // Callback for handling resource rename attempt.
@@ skipping 148 matching lines @@
                             const FilePath& search_file_path,
                             const FindEntryCallback& callback,
                             GDataErrorCode error,
                             scoped_ptr<base::Value> feed_data);
 
   // Starts root feed load from the server. Value of |start_changestamp|
   // determines the type of feed to load - 0 means root feed, every other
   // value would trigger delta feed.
   // In the case of loading the root feed we use |root_feed_changestamp| as its
   // initial changestamp value since it does not come with that info.
-  // If successful, it will try to find the file upon retrieval completion.
+  // When done |load_feed_callback| is invoked.
+  // |entry_found_callback| is used only when this is invoked while searching
+  // for file info, and is used in |load_feed_callback|. If successful, it will
+  // try to find the file upon retrieval completion.
+  // |should_fetch_multiple_feeds| is true iff don't want to stop feed loading
+  // after we retrieve first feed chunk.
+  // If invoked as a part of content search, query will be set in
+  // |search_query|.
   void LoadFeedFromServer(int start_changestamp,
                           int root_feed_changestamp,
+                          bool should_fetch_multiple_feeds,
                           const FilePath& search_file_path,
-                          const FindEntryCallback& callback);
+                          const std::string& search_query,
+                          const FindEntryCallback& entry_found_callback,
+                          const LoadDocumentFeedCallback& load_feed_callback);
+
+  // Callback for handling feed content fetching while searching for file info.
+  // This callback is invoked after async feed fetch operation that was
+  // invoked by StartDirectoryRefresh() completes. This callback will update
+  // the content of the refreshed directory object and continue initially
+  // started FindEntryByPath() request.
+  void OnFeedFromServerLoaded(GetDocumentsParams* params,
+                              base::PlatformFileError status);
 
   // Starts root feed load from the cache. If successful, it will try to find
   // the file upon retrieval completion. In addition to that, it will
   // initate retrieval of the root feed from the server if
   // |should_load_from_server| is set.
   void LoadRootFeedFromCache(bool should_load_from_server,
                              const FilePath& search_file_path,
                              const FindEntryCallback& callback);
 
   // Callback for handling root directory refresh from the cache.
@@ skipping 359 matching lines @@
                               base::PlatformFileError error,
                               const std::string& resource_id,
                               const std::string& md5);
 
   // Changes state of hosted documents visibility, triggers directory refresh.
   void SetHideHostedDocuments(bool hide);
 
   // Initializes preference change observer.
   void InitializePreferenceObserver();
 
+  // Tests if we are allowed to create new directory in the provided directory.
+  bool ShouldCreateDirectory(const FilePath& directory_path);
+
   // Called when an entry is found for GetEntryInfoByPathAsync().
   void OnGetEntryInfo(const GetEntryInfoCallback& callback,
                       base::PlatformFileError error,
                       const FilePath& entry_path,
                       GDataEntry* entry);
 
   // Called when an entry is found for GetFileInfoByPathAsync().
   void OnGetFileInfo(const GetFileInfoCallback& callback,
                      base::PlatformFileError error,
                      const FilePath& directory_path,
                      GDataEntry* entry);
 
   // Called when an entry is found for ReadDirectoryByPathAsync().
   void OnReadDirectory(const ReadDirectoryCallback& callback,
                        base::PlatformFileError error,
                        const FilePath& directory_path,
                        GDataEntry* entry);
 
   // Finds file info by using virtual |file_path|. This call will also
   // retrieve and refresh file system content from server and disk cache.
   void FindEntryByPathAsyncOnUIThread(const FilePath& search_file_path,
                                       const FindEntryCallback& callback);
 
   // The following functions are used to forward calls to asynchronous public
   // member functions to UI thread.
+  void SearchAsyncOnUIThread(const std::string& search_query,

[tbarzic, 2012/05/03 23:56:18]

indent!

+                                        const ReadDirectoryCallback& callback);
   void CopyOnUIThread(const FilePath& src_file_path,
                       const FilePath& dest_file_path,
                       const FileOperationCallback& callback);
   void MoveOnUIThread(const FilePath& src_file_path,
                       const FilePath& dest_file_path,
                       const FileOperationCallback& callback);
   void RemoveOnUIThread(const FilePath& file_path,
                         bool is_recursive,
                         const FileOperationCallback& callback);
   void CreateDirectoryOnUIThread(const FilePath& directory_path,
@@ skipping 89 matching lines @@
 };
 
 // Sets the free disk space getter for testing.
 // The existing getter is deleted.
 void SetFreeDiskSpaceGetterForTesting(
     FreeDiskSpaceGetterInterface* getter);
 
 }  // namespace gdata
 
 #endif  // CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILE_SYSTEM_H_