Refresh drive file system metadata for entries in search results.

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 2188 matching lines @@
                                         params.get_file_callback,
                                         params.get_download_data_callback)));
 }
 
 void GDataFileSystem::OnGetDocumentEntry(const FilePath& cache_file_path,
                                          const GetFileFromCacheParams& params,
                                          GDataErrorCode status,
                                          scoped_ptr<base::Value> data) {
   base::PlatformFileError error = GDataToPlatformError(status);
 
-  GDataEntry* fresh_entry = NULL;
+  scoped_ptr<GDataEntry> fresh_entry;
   if (error == base::PLATFORM_FILE_OK) {
     scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::ExtractAndParse(*data));
     if (doc_entry.get()) {
-      fresh_entry =
-          GDataEntry::FromDocumentEntry(NULL, doc_entry.get(), root_.get());
+      fresh_entry.reset(
+          GDataEntry::FromDocumentEntry(NULL, doc_entry.get(), root_.get()));
     }
-    if (!fresh_entry || !fresh_entry->AsGDataFile()) {
+    if (!fresh_entry.get() || !fresh_entry->AsGDataFile()) {
       LOG(ERROR) << "Got invalid entry from server for " << params.resource_id;
       error = base::PLATFORM_FILE_ERROR_FAILED;
     }
   }
 
   if (error != base::PLATFORM_FILE_OK) {
     if (!params.get_file_callback.is_null()) {
       params.get_file_callback.Run(error,
                                    cache_file_path,
                                    params.mime_type,
                                    REGULAR_FILE);
     }
     return;
   }
 
   GURL content_url = fresh_entry->content_url();
   int64 file_size = fresh_entry->file_info().size;
 
   {
     base::AutoLock lock(lock_);  // We're accessing the root.
-    GDataEntry* old_entry = root_->GetEntryByResourceId(params.resource_id);
-    GDataDirectory* entry_parent = old_entry ? old_entry->parent() : NULL;
-
-    if (entry_parent) {
-      DCHECK_EQ(fresh_entry->resource_id(), old_entry->resource_id());
-      DCHECK(fresh_entry->AsGDataFile());
-      DCHECK(old_entry->AsGDataFile());
-
-      entry_parent->RemoveEntry(old_entry);
-      entry_parent->AddEntry(fresh_entry);
-    }
+    DCHECK_EQ(params.resource_id, fresh_entry->resource_id());
+    root_->RefreshFile(fresh_entry.Pass());
   }
 
   bool* has_enough_space = new bool(false);
   PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       base::Bind(&GDataFileSystem::FreeDiskSpaceIfNeededFor,
                  base::Unretained(this),
                  file_size,
                  has_enough_space),
       base::Bind(&GDataFileSystem::StartDownloadFileIfEnoughSpace,
@@ skipping 639 matching lines @@
 
   if (!params.callback.is_null()) {
     // Finally done with the create request.
     params.callback.Run(base::PLATFORM_FILE_OK);
   }
 }
 
 void GDataFileSystem::OnSearch(const ReadDirectoryCallback& callback,
                                GetDocumentsParams* params,
                                base::PlatformFileError error) {
+  if (error != base::PLATFORM_FILE_OK) {
+    if (!callback.is_null())
+      callback.Run(error, scoped_ptr<GDataDirectoryProto>());
+    return;
+  }
+
+  // We will refresh values in root for entries received in the feed.
+  base::AutoLock lock(lock_);
+
   // The search results will be returned using virtual directory.
   // The directory is not really part of the file system, so it has no parent or
   // root.
   scoped_ptr<GDataDirectory> search_dir(new GDataDirectory(NULL, NULL));
 
-  base::AutoLock lock(lock_);
+  DCHECK_EQ(1u, params->feed_list->size());
+  DocumentFeed* feed = params->feed_list->at(0);
 
-  int delta_feed_changestamp = 0;
-  int num_regular_files = 0;
-  int num_hosted_documents = 0;
-  FileResourceIdMap file_map;
-  if (error == base::PLATFORM_FILE_OK) {
-    error = FeedToFileResourceMap(*params->feed_list,
-                                  &file_map,
-                                  &delta_feed_changestamp,
-                                  &num_regular_files,
-                                  &num_hosted_documents);
-  }
+  // Go through all entires generated by the feed and add them to the search
+  // result directory.
+  for (size_t i = 0; i < feed->entries().size(); ++i){
+    DocumentEntry* doc = feed->entries()->at(i);
+    GDataEntry* entry = GDataEntry::FromDocumentEntry(NULL, doc, root_.get());
 
-  if (error == base::PLATFORM_FILE_OK) {
-    std::set<FilePath> ignored;
+    if (!entry)
+      continue;
 
-    // Go through all entires generated by the feed and add them to the search
-    // result directory.
-    for (FileResourceIdMap::const_iterator it = file_map.begin();
-         it != file_map.end(); ++it) {
-      scoped_ptr<GDataEntry> entry(it->second);
-      DCHECK_EQ(it->first, entry->resource_id());
-      DCHECK(!entry->is_deleted());
+    DCHECK_EQ(doc->resource_id(), entry->resource_id());
+    DCHECK(!entry->is_deleted());
 
-      entry->set_title(entry->resource_id() + "." + entry->title());
+    if (entry->AsGDataFile()) {
+      // We have to make a new copy of the entry because |search_dir| will later
+      // take ownership of |entry|.
+      scoped_ptr<GDataEntry> entry_to_save(
+          GDataEntry::FromDocumentEntry(NULL, doc, root_.get()));
+      DCHECK(entry_to_save.get());
+      DCHECK_EQ(entry->resource_id(), entry_to_save->resource_id());
+      root_->RefreshFile(entry_to_save.Pass());
+    }
 
-      search_dir->AddEntry(entry.release());
-    }
+    entry->set_title(entry->resource_id() + "." + entry->title());
+
+    search_dir->AddEntry(entry);
   }
 
   scoped_ptr<GDataDirectoryProto> directory_proto(new GDataDirectoryProto);
   search_dir->ToProto(directory_proto.get());
 
-  if (!callback.is_null()) {
+  if (!callback.is_null())
     callback.Run(error, directory_proto.Pass());
-  }
 }
 
 void GDataFileSystem::SearchAsync(const std::string& search_query,
                                   const ReadDirectoryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(base::Bind(&GDataFileSystem::SearchAsyncOnUIThread,
                                ui_weak_ptr_,
                                search_query,
                                CreateRelayCallback(callback)));
@@ skipping 2140 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