drive: Supports shared-with-me search in searchDriveMetadata().

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 "base/bind.h"
 #include "base/string_util.h"
 #include "chrome/browser/chromeos/drive/drive_file_system_util.h"
@@ skipping 15 matching lines @@
 
   if (a_file_info.last_accessed() != b_file_info.last_accessed())
     return a_file_info.last_accessed() > b_file_info.last_accessed();
 
   // When the entries have the same last access time (which happens quite often
   // because Drive server doesn't set the field until an entry is viewed via
   // drive.google.com), we use last modified time as the tie breaker.
   return a_file_info.last_modified() > b_file_info.last_modified();
 }
 
+// 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.
+bool IsEligibleEntry(const DriveEntryProto& entry, 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();
+
+  return true;
+}
+
+// Returns true if this search needs to traverse the tree under |entry|.
+bool ShouldReadDirectory(const DriveEntryProto& entry, int options) {
+  // Cannot read non-directory.
+  if (!entry.file_info().is_directory())
+    return false;
+
+  // This is a directory.
+  // Shared-with-me search do not go into a share-with-me directory.
+  if (options & SEARCH_METADATA_SHARED_WITH_ME)
+    return !entry.shared_with_me();
+
+  return true;
+}
+
 }  // namespace
 
 // Helper class for searching the local resource metadata.
 class SearchMetadataHelper {
  public:
   SearchMetadataHelper(DriveResourceMetadata* resource_metadata,
                        const std::string& query,
                        int options,
                        int at_most_num_matches,
                        const SearchMetadataCallback& callback)
@@ skipping 34 matching lines @@
     }
     DCHECK(entries);
 
     --num_pending_reads_;
     for (size_t i = 0; i < entries->size(); ++i) {
       const DriveEntryProto& entry = entries->at(i);
       const base::FilePath current_path = parent_path.Append(
           base::FilePath::FromUTF8Unsafe(entry.base_name()));
 
       // Recursively reading the sub directory.
-      if (entry.file_info().is_directory()) {
+      if (ShouldReadDirectory(entry, options_)) {
         ++num_pending_reads_;
         resource_metadata_->ReadDirectoryByPath(
             current_path,
             base::Bind(&SearchMetadataHelper::DidReadDirectoryByPath,
                        weak_ptr_factory_.GetWeakPtr(),
                        current_path));
       }
 
-      // Skip the hosted document if |options| has
-      // SEARCH_METADATA_EXCLUDE_HOSTED_DOCUMENTS, which is set by
-      // DriveFileSystem::SearchMetadata() based on the preference.
-      if ((options_ & SEARCH_METADATA_EXCLUDE_HOSTED_DOCUMENTS) &&
-          entry.file_specific_info().is_hosted_document())
-        continue;
-
-      // Skip the directory if SEARCH_METADATA_EXCLUDE_DIRECTORIES is requested.
-      if ((options_ & SEARCH_METADATA_EXCLUDE_DIRECTORIES) &&
-          entry.file_info().is_directory())
-        continue;
-
-      // Add it to the search result if the base name of the file contains
-      // the query.
+      // Add it to the search result if the entry is eligible for the given
+      // |options| and matches the query. The base name of the entry must
+      // contains |query| to match the query.
       std::string highlighted;
-      if (FindAndHighlight(entry.base_name(), query_, &highlighted)) {
+      if (IsEligibleEntry(entry, options_) &&
+          FindAndHighlight(entry.base_name(), query_, &highlighted)) {
         results_->push_back(
             MetadataSearchResult(current_path, entry, highlighted));
       }
+

[yoshiki, 2013/04/10 04:29:49]

nit: remove

[Haruki Sato, 2013/04/10 04:51:13]

Done.

     }
 
     if (num_pending_reads_ == 0) {
       // Search is complete. Send the result to the callback.
       std::sort(results_->begin(), results_->end(), &CompareByTimestamp);
       if (results_->size() > static_cast<size_t>(at_most_num_matches_)) {
         // Don't use resize() as it requires a default constructor.
         results_->erase(results_->begin() + at_most_num_matches_,
                         results_->end());
       }
@@ skipping 70 matching lines @@
   if (num_matches == 0)
     return false;
 
   std::string remaining_piece = text.substr(cursor);
   highlighted_text->append(net::EscapeForHTML(remaining_piece));
 
   return true;
 }
 
 }  // namespace drive