drive: Report error from SearchMetadata

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"
@@ skipping 134 matching lines @@
       (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().
-scoped_ptr<MetadataSearchResultVector> SearchMetadataOnBlockingPool(
-    ResourceMetadata* resource_metadata,
-    FileCache* cache,
-    const std::string& query_text,
-    int options,
-    int at_most_num_matches) {
+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,
                           query_text.empty() ? NULL : &query,
                           options,
                           at_most_num_matches, &result_candidates, it->Get());
   }
 
   // Prepare the result.
-  scoped_ptr<MetadataSearchResultVector> results(
-      new MetadataSearchResultVector);
   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())
-      continue;
+      return FILE_ERROR_FAILED;
     results->push_back(*result_candidates.top());
     results->back().path = path;
   }
 
   // Reverse the order here because |result_candidates| puts the most
   // uninteresting candidate at the top.
   std::reverse(results->begin(), results->end());
 
-  return results.Pass();
+  return FILE_ERROR_OK;
 }
+
+void RunSearchMetadataCallback(const SearchMetadataCallback& callback,
+                               scoped_ptr<MetadataSearchResultVector> results,
+                               FileError error) {
+  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());
 
-  // TODO(hashimoto): Report error code from ResourceMetadata::IterateEntries
-  // and stop binding FILE_ERROR_OK to |callback|.
+  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),
-                                   base::Bind(callback, FILE_ERROR_OK));
+                                              at_most_num_matches,
+                                              results_ptr),
+                                   base::Bind(&RunSearchMetadataCallback,
+                                              callback,
+                                              base::Passed(&results)));
 }
 
 bool FindAndHighlight(
     const std::string& text,
     base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents* query,
     std::string* highlighted_text) {
   DCHECK(query);
   DCHECK(highlighted_text);
   highlighted_text->clear();
 
   string16 text16 = base::UTF8ToUTF16(text);
   size_t match_start = 0;
   size_t match_length = 0;
   if (!query->Search(text16, &match_start, &match_length))
     return false;
 
   string16 pre = text16.substr(0, match_start);
   string16 match = text16.substr(match_start, match_length);
   string16 post = text16.substr(match_start + match_length);
   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