Move FindEntryDelegate and friends to separate file.

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 670 matching lines @@
   if (!net::GetMimeTypeFromExtension(local_file.Extension(),
                                      &upload_file_info->content_type)) {
     upload_file_info->content_type= kMimeTypeOctetStream;
   }
 
   *error = base::PLATFORM_FILE_OK;
 }
 
 }  // 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.
-class FindEntryCallbackRelayDelegate : public FindEntryDelegate {
- public:
-  explicit FindEntryCallbackRelayDelegate(const FindEntryCallback& callback);
-  virtual ~FindEntryCallbackRelayDelegate();
-
- private:
-  // FindEntryDelegate overrides.
-  virtual void OnDone(base::PlatformFileError error,
-                      const FilePath& directory_path,
-                      GDataEntry* entry) OVERRIDE;
-
-  const FindEntryCallback callback_;
-};
-
-FindEntryCallbackRelayDelegate::FindEntryCallbackRelayDelegate(
-    const FindEntryCallback& callback) : callback_(callback) {
-}
-
-FindEntryCallbackRelayDelegate::~FindEntryCallbackRelayDelegate() {
-}
-
-void FindEntryCallbackRelayDelegate::OnDone(base::PlatformFileError error,
-                                            const FilePath& directory_path,
-                                            GDataEntry* entry) {
-  if (!callback_.is_null()) {
-    callback_.Run(error, directory_path, entry);
-  }
-}
-
-// ReadOnlyFindEntryDelegate class implementation.
-
-ReadOnlyFindEntryDelegate::ReadOnlyFindEntryDelegate() : entry_(NULL) {
-}
-
-void ReadOnlyFindEntryDelegate::OnDone(base::PlatformFileError error,
-                                       const FilePath& directory_path,
-                                       GDataEntry* entry) {
-  DCHECK(!entry_);
-  if (error == base::PLATFORM_FILE_OK)
-    entry_ = entry;
-  else
-    entry_ = NULL;
-}
-
 // GDataFileProperties struct implementation.
 
 GDataFileProperties::GDataFileProperties() : is_hosted_document(false) {
 }
 
 GDataFileProperties::~GDataFileProperties() {
 }
 
 // GDataFileSystem::GetDocumentsParams struct implementation.
 
@@ skipping 184 matching lines @@
   // TokenFetcher, used in DocumentsService, must be run on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   documents_service_->Authenticate(callback);
 }
 
 void GDataFileSystem::FindEntryByPathSync(
     const FilePath& search_file_path,
     FindEntryDelegate* delegate) {
   base::AutoLock lock(lock_);
-  UnsafeFindEntryByPath(search_file_path, delegate);
+  root_->FindEntryByPath(search_file_path, delegate);
 }
 
 void GDataFileSystem::FindEntryByResourceIdSync(
     const std::string& resource_id,
     FindEntryDelegate* delegate) {
   base::AutoLock lock(lock_);  // To access the cache map.
 
   GDataFile* file = NULL;
   GDataEntry* entry = root_->GetEntryByResourceId(resource_id);
   if (entry)
@@ skipping 985 matching lines @@
     scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
     const ResumeFileUploadCallback& callback,
     const ResumeUploadResponse& response,
     scoped_ptr<DocumentEntry> new_entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!callback.is_null())
     message_loop_proxy->PostTask(FROM_HERE,
         base::Bind(callback, response, base::Passed(&new_entry)));
 }
 
-void GDataFileSystem::UnsafeFindEntryByPath(
-    const FilePath& file_path,
-    FindEntryDelegate* delegate) {
-  DCHECK(delegate);
-  lock_.AssertAcquired();
-
-  std::vector<FilePath::StringType> components;
-  file_path.GetComponents(&components);
-
-  GDataDirectory* current_dir = root_.get();
-  FilePath directory_path;
-  for (size_t i = 0; i < components.size() && current_dir; i++) {
-    directory_path = directory_path.Append(current_dir->file_name());
-
-    // Last element must match, if not last then it must be a directory.
-    if (i == components.size() - 1) {
-      if (current_dir->file_name() == components[i])
-        delegate->OnDone(base::PLATFORM_FILE_OK, directory_path, current_dir);
-      else
-        delegate->OnDone(base::PLATFORM_FILE_ERROR_NOT_FOUND, FilePath(), NULL);
-
-      return;
-    }
-
-    // Not the last part of the path, search for the next segment.
-    GDataFileCollection::const_iterator file_iter =
-        current_dir->children().find(components[i + 1]);
-    if (file_iter == current_dir->children().end()) {
-      delegate->OnDone(base::PLATFORM_FILE_ERROR_NOT_FOUND, FilePath(), NULL);
-      return;
-    }
-
-    // Found file, must be the last segment.
-    if (file_iter->second->file_info().is_directory) {
-      // Found directory, continue traversal.
-      current_dir = file_iter->second->AsGDataDirectory();
-    } else {
-      if ((i + 1) == (components.size() - 1)) {
-        delegate->OnDone(base::PLATFORM_FILE_OK,
-                         directory_path,
-                         file_iter->second);
-      } else {
-        delegate->OnDone(base::PLATFORM_FILE_ERROR_NOT_FOUND, FilePath(), NULL);
-      }
-
-      return;
-    }
-  }
-  delegate->OnDone(base::PLATFORM_FILE_ERROR_NOT_FOUND, FilePath(), NULL);
-}
-
 bool GDataFileSystem::GetFileInfoByPath(
     const FilePath& file_path, GDataFileProperties* properties) {
   DCHECK(properties);
   base::AutoLock lock(lock_);
   GDataEntry* entry = GetGDataEntryByPath(file_path);
   if (!entry)
     return false;
 
   properties->file_info = entry->file_info();
   properties->resource_id = entry->resource_id();
@@ skipping 23 matching lines @@
   NOTREACHED() << "Called on an unexpected thread: "
                << base::PlatformThread::CurrentId();
   return ui_weak_ptr_factory_->GetWeakPtr();
 }
 
 GDataEntry* GDataFileSystem::GetGDataEntryByPath(
     const FilePath& file_path) {
   lock_.AssertAcquired();
   // Find directory element within the cached file system snapshot.
   ReadOnlyFindEntryDelegate find_delegate;
-  UnsafeFindEntryByPath(file_path, &find_delegate);
+  root_->FindEntryByPath(file_path, &find_delegate);
   return find_delegate.entry();
 }
 
 void GDataFileSystem::GetCacheState(const std::string& resource_id,
                                     const std::string& md5,
                                     const GetCacheStateCallback& callback) {
   // This method originates from GDataFile::GetCacheState, which already locks,
   // so we shouldn't lock here.
   UnsafeInitializeCacheIfNecessary();
 
@@ skipping 700 matching lines @@
     RemoveFromCache(resource_id, CacheOperationCallback());
 
   return base::PLATFORM_FILE_OK;
 }
 
 base::PlatformFileError GDataFileSystem::UpdateFromFeed(
     const std::vector<DocumentFeed*>& feed_list,
     ContentOrigin origin,
     int start_changestamp,
     int root_feed_changestamp) {
-   DVLOG(1) << "Updating directory with a feed";
+  DVLOG(1) << "Updating directory with a feed";
 
   bool is_delta_feed = start_changestamp != 0;
   // We need to lock here as well (despite FindEntryByPath lock) since directory
   // instance below is a 'live' object.
   base::AutoLock lock(lock_);
   bool should_notify_initial_load = root_->origin() == INITIALIZING;
 
   root_->set_origin(origin);
   root_->set_refresh_time(base::Time::Now());
 
@@ skipping 169 matching lines @@
     const DocumentFeed* feed = feed_list[i];
 
     // Get upload url from the root feed. Links for all other collections will
     // be handled in GDatadirectory::FromDocumentEntry();
     if (i == 0) {
       const Link* root_feed_upload_link =
           feed->GetLinkByType(Link::RESUMABLE_CREATE_MEDIA);
       if (root_feed_upload_link)
         root_->set_upload_url(root_feed_upload_link->href());
       *feed_changestamp = feed->largest_changestamp();
-      DCHECK(*feed_changestamp >= 0);
+      DCHECK_GE(*feed_changestamp, 0);
     }
 
     for (ScopedVector<DocumentEntry>::const_iterator iter =
              feed->entries().begin();
          iter != feed->entries().end(); ++iter) {
       DocumentEntry* doc = *iter;
       GDataEntry* entry = GDataEntry::FromDocumentEntry(NULL, doc,
                                                              root_.get());
       // Some document entries don't map into files (i.e. sites).
       if (!entry)
@@ skipping 1428 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