Move FindEntryDelegate and friends to separate file.

chrome/browser/chromeos/gdata/gdata_files.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_FILES_H_
 #define CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILES_H_
 #pragma once
 
 #include <map>
 #include <string>
 
 #include "base/callback.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/memory/weak_ptr.h"
 #include "base/platform_file.h"
 #include "base/synchronization/lock.h"
 #include "chrome/browser/chromeos/gdata/gdata_params.h"
 #include "chrome/browser/chromeos/gdata/gdata_parser.h"
 #include "chrome/browser/chromeos/gdata/gdata_uploader.h"
 #include "chrome/browser/profiles/profile_keyed_service.h"
 #include "chrome/browser/profiles/profile_keyed_service_factory.h"
 
 namespace gdata {
 
+class FindEntryDelegate;
 class GDataFile;
 class GDataDirectory;
 class GDataRootDirectory;
 
 class GDataEntryProto;
 class GDataFileProto;
 class GDataDirectoryProto;
 class GDataRootDirectoryProto;
 
 // Directory content origin.
@@ skipping 36 matching lines @@
                                           DocumentEntry* doc,
                                           GDataRootDirectory* root);
 
   // Serialize/Parse to/from string via proto classes.
   // TODO(achuith): Correctly set up parent_ and root_ links in
   // FromProtoString.
   void SerializeToString(std::string* serialized_proto) const;
   static scoped_ptr<GDataEntry> FromProtoString(
       const std::string& serialized_proto);
 
-  // Convert to/from proto.
+  // Converts to/from proto.
   void FromProto(const GDataEntryProto& proto);
   void ToProto(GDataEntryProto* proto) const;
 
   // Escapes forward slashes from file names with magic unicode character
   // \u2215 pretty much looks the same in UI.
   static std::string EscapeUtf8FileName(const std::string& input);
 
   // Unescapes what was escaped in EScapeUtf8FileName.
   static std::string UnescapeUtf8FileName(const std::string& input);
 
@@ skipping 84 matching lines @@
   };
 
   explicit GDataFile(GDataDirectory* parent, GDataRootDirectory* root);
   virtual ~GDataFile();
   virtual GDataFile* AsGDataFile() OVERRIDE;
 
   static GDataEntry* FromDocumentEntry(GDataDirectory* parent,
                                           DocumentEntry* doc,
                                           GDataRootDirectory* root);
 
-  // Convert to/from proto.
+  // Converts to/from proto.
   void FromProto(const GDataFileProto& proto);
   void ToProto(GDataFileProto* proto) const;
 
   static bool IsCachePresent(int cache_state) {
     return cache_state & CACHE_STATE_PRESENT;
   }
   static bool IsCachePinned(int cache_state) {
     return cache_state & CACHE_STATE_PINNED;
   }
   static bool IsCacheDirty(int cache_state) {
@@ skipping 63 matching lines @@
 class GDataDirectory : public GDataEntry {
  public:
   GDataDirectory(GDataDirectory* parent, GDataRootDirectory* root);
   virtual ~GDataDirectory();
   virtual GDataDirectory* AsGDataDirectory() OVERRIDE;
 
   static GDataEntry* FromDocumentEntry(GDataDirectory* parent,
                                           DocumentEntry* doc,
                                           GDataRootDirectory* root);
 
-  // Convert to/from proto.
+  // Converts to/from proto.
   void FromProto(const GDataDirectoryProto& proto);
   void ToProto(GDataDirectoryProto* proto) const;
 
   // Adds child file to the directory and takes over the ownership of |file|
   // object. The method will also do name de-duplication to ensure that the
   // exposed presentation path does not have naming conflicts. Two files with
   // the same name "Foo" will be renames to "Foo (1)" and "Foo (2)".
   void AddEntry(GDataEntry* entry);
 
   // Takes the ownership of |entry| from its current parent. If this directory
@@ skipping 123 matching lines @@
   // Last time when we dumped serialized file system to disk.
   const base::Time& last_serialized() const { return last_serialized_; }
   void set_last_serialized(const base::Time& time) { last_serialized_ = time; }
   // Size of serialized file system on disk in bytes.
   const size_t serialized_size() const { return serialized_size_; }
   void set_serialized_size(size_t size) { serialized_size_ = size; }
 
   // GDataEntry implementation.
   virtual GDataRootDirectory* AsGDataRootDirectory() OVERRIDE;
 
-  // Add the entry to resource map.
+  // Adds the entry to resource map.
   void AddEntryToResourceMap(GDataEntry* entry);
 
-  // Remove the entry from resource map.
+  // Removes the entry from resource map.
   void RemoveEntryFromResourceMap(GDataEntry* entry);
 
-  // Remove the entries from resource map.
+  // Removes the entries from resource map.
   void RemoveEntriesFromResourceMap(const GDataFileCollection& children);
 
+  // Searches for |file_path| triggering callback in |delegate|.
+  void FindEntryByPath(const FilePath& file_path,
+                       FindEntryDelegate* delegate);
+
   // Returns the GDataEntry* with the corresponding |resource_id|.
   GDataEntry* GetEntryByResourceId(const std::string& resource_id);
 
-  // Set |cache_map_| data member to formal parameter |new_cache_map|.
+  // Sets |cache_map_| data member to formal parameter |new_cache_map|.
   void SetCacheMap(const CacheMap& new_cache_map);
 
   // Updates cache map with entry corresponding to |resource_id|.
   // Creates new entry if it doesn't exist, otherwise update the entry.
   void UpdateCacheMap(const std::string& resource_id,
                       const std::string& md5,
                       CacheSubDirectoryType subdir,
                       int cache_state);
 
   // Removes entry corresponding to |resource_id| from cache map.
   void RemoveFromCacheMap(const std::string& resource_id);
 
   // Returns the cache entry for file corresponding to |resource_id| and |md5|
   // if entry exists in cache map.  Otherwise, returns NULL.
   // |md5| can be empty if only matching |resource_id| is desired, which may
   // happen when looking for pinned entries where symlinks' filenames have no
   // extension and hence no md5.
   CacheEntry* GetCacheEntry(const std::string& resource_id,
                             const std::string& md5);
 
-  // Remove temporary files (files in CACHE_TYPE_TMP) from the cache map.
+  // Removes temporary files (files in CACHE_TYPE_TMP) from the cache map.
   void RemoveTemporaryFilesFromCacheMap();
 
-  // Serialize/Parse to/from string via proto classes.
+  // Serializes/Parses to/from string via proto classes.
   void SerializeToString(std::string* serialized_proto) const;
   bool ParseFromString(const std::string& serialized_proto);
 
-  // Convert to/from proto.
+  // Converts to/from proto.
   void FromProto(const GDataRootDirectoryProto& proto);
   void ToProto(GDataRootDirectoryProto* proto) const;
 
  private:
   ResourceMap resource_map_;
   CacheMap cache_map_;
 
   base::Time last_serialized_;
   int largest_changestamp_;
   size_t serialized_size_;
 
   DISALLOW_COPY_AND_ASSIGN(GDataRootDirectory);
 };
 
 }  // namespace gdata
 
 #endif  // CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILES_H_