drive: Add ResourceMetadataStorage::Iterator::GetCacheEntry()

chrome/browser/chromeos/drive/search_metadata.cc

 // Copyright (c) 2013 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/drive/search_metadata.h"
 
 #include <algorithm>
 #include <queue>
 
 #include "base/bind.h"
 #include "base/i18n/string_search.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/chromeos/drive/file_cache.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/escape.h"
 
 using content::BrowserThread;
 
 namespace drive {
 namespace internal {
 
 namespace {
@@ skipping 52 matching lines @@
 
 // Returns true if |entry| is eligible for the search |options| and should be
 // tested for the match with the query.  If
 // SEARCH_METADATA_EXCLUDE_HOSTED_DOCUMENTS is requested, the hosted documents
 // are skipped. If SEARCH_METADATA_EXCLUDE_DIRECTORIES is requested, the
 // directories are skipped. If SEARCH_METADATA_SHARED_WITH_ME is requested, only
 // the entries with shared-with-me label will be tested. If
 // SEARCH_METADATA_OFFLINE is requested, only hosted documents and cached files
 // match with the query. This option can not be used with other options.
 bool IsEligibleEntry(const ResourceEntry& entry,
-                     internal::FileCache* cache,
+                     ResourceMetadata::Iterator* it,
                      int options) {
   if ((options & SEARCH_METADATA_EXCLUDE_HOSTED_DOCUMENTS) &&
       entry.file_specific_info().is_hosted_document())
     return false;
 
   if ((options & SEARCH_METADATA_EXCLUDE_DIRECTORIES) &&
       entry.file_info().is_directory())
     return false;
 
   if (options & SEARCH_METADATA_SHARED_WITH_ME)
     return entry.shared_with_me();
 
   if (options & SEARCH_METADATA_OFFLINE) {
     if (entry.file_specific_info().is_hosted_document())
       return true;
     FileCacheEntry cache_entry;
-    cache->GetCacheEntry(entry.resource_id(),
-                         std::string(),
-                         &cache_entry);
+    it->GetCacheEntry(&cache_entry);
     return cache_entry.is_present();
   }
 
   // Exclude "drive", "drive/root", and "drive/other".
   if (entry.resource_id() == util::kDriveGrandRootSpecialResourceId ||
       entry.parent_resource_id() == util::kDriveGrandRootSpecialResourceId) {
     return false;
   }
 
   return true;
 }
 
 // Used to implement SearchMetadata.
 // Adds entry to the result when appropriate.
 // In particular, if |query| is non-null, only adds files with the name matching
 // the query.
 void MaybeAddEntryToResult(
     ResourceMetadata* resource_metadata,
-    FileCache* cache,
+    ResourceMetadata::Iterator* it,
     base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents* query,
     int options,
     size_t at_most_num_matches,
     ScopedPriorityQueue<MetadataSearchResult,
-                        MetadataSearchResultComparator>* result_candidates,
-    const ResourceEntry& entry) {
+                        MetadataSearchResultComparator>* result_candidates) {
   DCHECK_GE(at_most_num_matches, result_candidates->size());
 
+  const ResourceEntry& entry = it->Get();
+
   // If the candidate set is already full, and this |entry| is old, do nothing.
   // We perform this check first in order to avoid the costly find-and-highlight
   // or FilePath lookup as much as possible.
   if (result_candidates->size() == at_most_num_matches &&
       !CompareByTimestamp(entry, result_candidates->top()->entry))
     return;
 
   // Add |entry| to the result if the entry is eligible for the given
   // |options| and matches the query. The base name of the entry must
   // contain |query| to match the query.
   std::string highlighted;
-  if (!IsEligibleEntry(entry, cache, options) ||
+  if (!IsEligibleEntry(entry, it, options) ||
       (query && !FindAndHighlight(entry.base_name(), query, &highlighted)))
     return;
 
   // Make space for |entry| when appropriate.
   if (result_candidates->size() == at_most_num_matches)
     result_candidates->pop();
   result_candidates->push(new MetadataSearchResult(entry, highlighted));
 }
 
 // Implements SearchMetadata().
 FileError SearchMetadataOnBlockingPool(ResourceMetadata* resource_metadata,
-                                       FileCache* cache,
                                        const std::string& query_text,
                                        int options,
                                        int at_most_num_matches,
                                        MetadataSearchResultVector* results) {
   ScopedPriorityQueue<MetadataSearchResult,
                       MetadataSearchResultComparator> result_candidates;
 
   // Prepare data structure for searching.
   base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents query(
       base::UTF8ToUTF16(query_text));
 
   // Iterate over entries.
   scoped_ptr<ResourceMetadata::Iterator> it = resource_metadata->GetIterator();
   for (; !it->IsAtEnd(); it->Advance()) {
-    MaybeAddEntryToResult(resource_metadata, cache,
+    MaybeAddEntryToResult(resource_metadata, it.get(),
                           query_text.empty() ? NULL : &query,
                           options,
-                          at_most_num_matches, &result_candidates, it->Get());
+                          at_most_num_matches, &result_candidates);
   }
 
   // Prepare the result.
   for (; !result_candidates.empty(); result_candidates.pop()) {
     // The path field of entries in result_candidates are empty at this point,
     // because we don't want to run the expensive metadata DB look up except for
     // the final results. Hence, here we fill the part.
     base::FilePath path = resource_metadata->GetFilePath(
         result_candidates.top()->entry.resource_id());
     if (path.empty())
@@ skipping 15 matching lines @@
   if (error != FILE_ERROR_OK)
     results.reset();
   callback.Run(error, results.Pass());
 }
 
 }  // namespace
 
 void SearchMetadata(
     scoped_refptr<base::SequencedTaskRunner> blocking_task_runner,
     ResourceMetadata* resource_metadata,
-    FileCache* cache,
     const std::string& query,
     int options,
     int at_most_num_matches,
     const SearchMetadataCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_LE(0, at_most_num_matches);
   DCHECK(!callback.is_null());
 
   scoped_ptr<MetadataSearchResultVector> results(
       new MetadataSearchResultVector);
   MetadataSearchResultVector* results_ptr = results.get();
   base::PostTaskAndReplyWithResult(blocking_task_runner.get(),
                                    FROM_HERE,
                                    base::Bind(&SearchMetadataOnBlockingPool,
                                               resource_metadata,
-                                              cache,
                                               query,
                                               options,
                                               at_most_num_matches,
                                               results_ptr),
                                    base::Bind(&RunSearchMetadataCallback,
                                               callback,
                                               base::Passed(&results)));
 }
 
 bool FindAndHighlight(
@@ skipping 16 matching lines @@
   highlighted_text->append(net::EscapeForHTML(base::UTF16ToUTF8(pre)));
   highlighted_text->append("<b>");
   highlighted_text->append(net::EscapeForHTML(base::UTF16ToUTF8(match)));
   highlighted_text->append("</b>");
   highlighted_text->append(net::EscapeForHTML(base::UTF16ToUTF8(post)));
   return true;
 }
 
 }  // namespace internal
 }  // namespace drive