Add gdata content search

chrome/browser/chromeos/gdata/gdata_util.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_util.h"
 
 #include <string>
 #include <vector>
 #include <utility>
 
@@ skipping 29 matching lines @@
 namespace {
 
 const char kGDataSpecialRootPath[] = "/special";
 
 const char kGDataMountPointPath[] = "/special/gdata";
 
 const FilePath::CharType* kGDataMountPointPathComponents[] = {
   "/", "special", "gdata"
 };
 
+const FilePath::CharType* kGDataSearchPathComponents[] = {
+  "gdata", ".search"
+};
+
 const int kReadOnlyFilePermissions = base::PLATFORM_FILE_OPEN |
                                      base::PLATFORM_FILE_READ |
                                      base::PLATFORM_FILE_EXCLUSIVE_READ |
                                      base::PLATFORM_FILE_ASYNC;
 
 class GetFileNameDelegate : public FindEntryDelegate {
  public:
   GetFileNameDelegate() {}
   virtual ~GetFileNameDelegate() {}
 
@@ skipping 109 matching lines @@
     *url = gdata::util::GetFileResourceUrl(resource_id, delegate.file_name());
     DVLOG(1) << "ModifyGDataFileResourceUrl " << *url;
   }
 }
 
 bool IsUnderGDataMountPoint(const FilePath& path) {
   return GetGDataMountPointPath() == path ||
          GetGDataMountPointPath().IsParent(path);
 }
 
+GDataSearchPathType GetSearchPathStatus(const FilePath& path) {
+  std::vector<std::string> components;
+  path.GetComponents(&components);
+  return GetSearchPathStatusForPathComponents(components);
+}
+
+GDataSearchPathType GetSearchPathStatusForPathComponents(
+    const std::vector<std::string>& path_components) {
+  if (path_components.size() < arraysize(kGDataSearchPathComponents))
+    return GDATA_SEARCH_PATH_INVALID;
+
+  for (size_t i = 0; i < arraysize(kGDataSearchPathComponents); i++) {
+    if (path_components[i] != kGDataSearchPathComponents[i])
+      return GDATA_SEARCH_PATH_INVALID;
+  }
+
+  switch (path_components.size()) {
+    case 2:
+      return GDATA_SEARCH_PATH_ROOT;
+    case 3:
+      return GDATA_SEARCH_PATH_QUERY;
+    case 4:
+      return GDATA_SEARCH_PATH_RESULT;
+    default:
+      return GDATA_SEARCH_PATH_RESULT_CHILD;
+  }
+}
+
+void ParseSearchFileName(const std::string& search_file_name,
+                         std::string* resource_id,
+                         std::string* original_file_name) {
+  DCHECK(resource_id);
+  DCHECK(original_file_name);
+
+  *resource_id = "";
+  *original_file_name = "";
+
+  size_t dot_index = search_file_name.find('.');
+  if (dot_index == std::string::npos)
+    return;
+
+  *resource_id = search_file_name.substr(0, dot_index);
+  if (search_file_name.length() - 1 > dot_index)
+    *original_file_name = search_file_name.substr(dot_index + 1);
+}
+
 FilePath ExtractGDataPath(const FilePath& path) {
   if (!IsUnderGDataMountPoint(path))
     return FilePath();
 
   std::vector<FilePath::StringType> components;
   path.GetComponents(&components);
 
   // -1 to include 'gdata'.
   FilePath extracted;
   for (size_t i = arraysize(kGDataMountPointPathComponents) - 1;
@@ skipping 125 matching lines @@
   // Assign the extracted extensions to md5 and extra_extension.
   int extension_count = extensions.size();
   *md5 = (extension_count > 0) ? extensions[extension_count - 1] :
                                  std::string();
   *extra_extension = (extension_count > 1) ? extensions[extension_count - 2] :
                                              std::string();
 }
 
 }  // namespace util
 }  // namespace gdata