Add gdata content search

chrome/browser/chromeos/gdata/gdata_files.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_files.h"
 
 #include <vector>
 
 #include "base/utf_string_conversions.h"
 #include "base/platform_file.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
 #include "chrome/browser/chromeos/gdata/find_entry_delegate.h"
 #include "chrome/browser/chromeos/gdata/gdata.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_parser.h"
+#include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "net/base/escape.h"
 
 namespace gdata {
 namespace {
 
 // Content refresh time.
 #ifndef NDEBUG
 const int kRefreshTimeInSec = 10;
 #else
 const int kRefreshTimeInSec = 5*60;
@@ skipping 285 matching lines @@
   }
   entry->set_file_name(full_file_name.value());
 
   DVLOG(1) << "AddEntry: dir = " << GetFilePath().value()
            << ", file = " + entry->file_name()
            << ", parent resource = " << entry->parent_resource_id()
            << ", resource = " + entry->resource_id();
 
 
   // Add entry to resource map.
-  root_->AddEntryToResourceMap(entry);
+  if (root_)
+    root_->AddEntryToResourceMap(entry);
+
   // Setup child and parent links.
   AddChild(entry);
   entry->SetParent(this);
 }
 
 bool GDataDirectory::TakeEntry(GDataEntry* entry) {
   DCHECK(entry);
   DCHECK(entry->parent());
 
   entry->parent()->RemoveChild(entry);
@@ skipping 58 matching lines @@
   DCHECK(entry);
 
   const std::string file_name(entry->file_name());
   GDataEntry* found_entry = FindChild(file_name);
   if (!found_entry)
     return false;
 
   DCHECK_EQ(entry, found_entry);
 
   // Remove entry from resource map first.
-  root_->RemoveEntryFromResourceMap(entry);
+  if (root_)
+    root_->RemoveEntryFromResourceMap(entry);
 
   // Then delete it from tree.
   child_files_.erase(file_name);
   child_directories_.erase(file_name);
 
   return true;
 }
 
 void GDataDirectory::RemoveChildren() {
   // Remove child files first.
   for (GDataFileCollection::const_iterator iter = child_files_.begin();
        iter != child_files_.end(); ++iter) {
-    root_->RemoveEntryFromResourceMap(iter->second);
+    if (root_)
+      root_->RemoveEntryFromResourceMap(iter->second);
   }
   STLDeleteValues(&child_files_);
   child_files_.clear();
 
   for (GDataDirectoryCollection::iterator iter = child_directories_.begin();
        iter != child_directories_.end(); ++iter) {
     GDataDirectory* dir = iter->second;
     // Remove directories recursively.
     dir->RemoveChildren();
-    root_->RemoveEntryFromResourceMap(dir);
+    if (root_)
+      root_->RemoveEntryFromResourceMap(dir);
   }
   STLDeleteValues(&child_directories_);
   child_directories_.clear();
 }
 
 // GDataRootDirectory::CacheEntry struct  implementation.
 
 std::string GDataRootDirectory::CacheEntry::ToString() const {
   std::vector<std::string> cache_states;
   if (GDataFile::IsCachePresent(cache_state))
     cache_states.push_back("present");
   if (GDataFile::IsCachePinned(cache_state))
     cache_states.push_back("pinned");
   if (GDataFile::IsCacheDirty(cache_state))
     cache_states.push_back("dirty");
 
   return base::StringPrintf("md5=%s, subdir=%s, cache_state=%s",
                             md5.c_str(),
                             CacheSubDirectoryTypeToString(sub_dir_type).c_str(),
                             JoinString(cache_states, ',').c_str());
 }
 
 // GDataRootDirectory class implementation.
 
 GDataRootDirectory::GDataRootDirectory()
     : ALLOW_THIS_IN_INITIALIZER_LIST(GDataDirectory(NULL, this)),
+      fake_search_directory_(new GDataDirectory(NULL, NULL)),
+      fake_search_query_directory_(new GDataDirectory(NULL, NULL)),
       largest_changestamp_(0), serialized_size_(0) {
   title_ = kGDataRootDirectory;
   SetFileNameFromTitle();
 }
 
 GDataRootDirectory::~GDataRootDirectory() {
   STLDeleteValues(&cache_map_);
   cache_map_.clear();
 
   resource_map_.clear();
 }
 
 GDataRootDirectory* GDataRootDirectory::AsGDataRootDirectory() {
   return this;
 }
 
 void GDataRootDirectory::AddEntryToResourceMap(GDataEntry* entry) {
   // GDataFileSystem has already locked.
   DVLOG(1) << "AddEntryToResourceMap " << entry->resource_id();
   resource_map_.insert(std::make_pair(entry->resource_id(), entry));
 }
 
 void GDataRootDirectory::RemoveEntryFromResourceMap(GDataEntry* entry) {
   // GDataFileSystem has already locked.
   resource_map_.erase(entry->resource_id());
 }
 
+bool GDataRootDirectory::ModifyFindEntryParamsIfSearchPath(
+    const FilePath& file_path,
+    std::vector<FilePath::StringType>* components,
+    GDataDirectory** current_dir,
+    FilePath* directory_path,
+    GDataEntry** entry_to_return) {
+  DCHECK(current_dir);
+  DCHECK(entry_to_return);
+  *entry_to_return = NULL;
+
+  // If the path is not search path, we don't have to do anything.
+  util::GDataSearchPathType path_type =
+      util::GetSearchPathStatusForPathComponents(*components);
+  if (path_type == util::GDATA_SEARCH_PATH_INVALID)
+    return true;
+
+  if (path_type == util::GDATA_SEARCH_PATH_ROOT) {
+    *directory_path = file_path.DirName();
+    *entry_to_return = fake_search_directory_.get();
+    (*entry_to_return)->set_file_name(file_path.BaseName().value());
+    return true;
+  }
+
+  if (path_type == util::GDATA_SEARCH_PATH_QUERY) {
+    *directory_path = file_path.DirName();
+    *entry_to_return = fake_search_query_directory_.get();
+    (*entry_to_return)->set_file_name(file_path.BaseName().value());
+    return true;
+  }
+
+  DCHECK(components->size() > 3);
+
+  FilePath::StringType resource_id;
+  FilePath::StringType file_name;
+  util::CrackSearchFileName((*components)[3],
+                            &resource_id, &file_name);
+  if (resource_id.empty() || file_name.empty())
+    return false;
+
+  GDataEntry* file_entry = GetEntryByResourceId(resource_id);
+  if (!file_entry)
+    return false;
+
+  // If |file_path| is indeed search file path, we should continue search from
+  // its parent directory. We have to ammend |components| to be relative to
+  // the |current_dir| (including the dir itself).
+  // We continue the search with the entrie's parent instead of the entry itself
+  // to make sure that the file with id |resource_id| really has the name
+  // |file_name|.
+  DCHECK(file_entry->parent());
+  *current_dir = file_entry->parent();
+
+  if ((*current_dir)->parent()) {
+    *directory_path = (*current_dir)->parent()->GetFilePath();
+  } else {
+    *directory_path = FilePath();
+  }
+
+  // Remove "gdata/.search" from path.
+  components->erase(components->begin(), components->begin() + 2);
+  (*components)[0] = (*current_dir)->file_name();
+  (*components)[1] = file_name;
+  return true;
+}
+
 void GDataRootDirectory::FindEntryByPath(
     const FilePath& file_path,
     FindEntryDelegate* delegate) {
   // GDataFileSystem has already locked.
   DCHECK(delegate);
 
   std::vector<FilePath::StringType> components;
   file_path.GetComponents(&components);
 
   GDataDirectory* current_dir = this;
   FilePath directory_path;
+
+  GDataEntry* entry_to_return = NULL;
+  if (!ModifyFindEntryParamsIfSearchPath(file_path, &components, &current_dir,
+                                         &directory_path, &entry_to_return)) {
+    delegate->OnDone(base::PLATFORM_FILE_ERROR_NOT_FOUND, FilePath(), NULL);
+    return;
+  }
+
+  if (entry_to_return) {
+    delegate->OnDone(base::PLATFORM_FILE_OK, directory_path, entry_to_return);
+    return;
+  }
+
   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])
+      if (current_dir->file_name() == components[i]) {
         delegate->OnDone(base::PLATFORM_FILE_OK, directory_path, current_dir);
-      else
+      } else {
         delegate->OnDone(base::PLATFORM_FILE_ERROR_NOT_FOUND, FilePath(), NULL);
-
+      }
       return;
     }
 
     // Not the last part of the path, search for the next segment.
     GDataEntry* entry = current_dir->FindChild(components[i + 1]);
     if (!entry) {
       delegate->OnDone(base::PLATFORM_FILE_ERROR_NOT_FOUND, FilePath(), NULL);
       return;
     }
 
@@ skipping 314 matching lines @@
   bool ok = proto->ParseFromString(serialized_proto);
   if (ok) {
     FromProto(*proto.get());
     set_origin(FROM_CACHE);
     set_refresh_time(base::Time::Now());
   }
   return ok;
 }
 
 }  // namespace gdata