[Sync] Speed up sync node browser/search in about:sync

chrome/browser/sync/syncable/syncable.cc

 // Copyright (c) 2011 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/sync/syncable/syncable.h"
 
 #include "build/build_config.h"
 
 #include <sys/stat.h>
 #if defined(OS_POSIX)
@@ skipping 18 matching lines @@
 
 #include "base/hash_tables.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/perftimer.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stl_util-inl.h"
 #include "base/time.h"
+#include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/engine/syncer_util.h"
 #include "chrome/browser/sync/protocol/proto_value_conversions.h"
 #include "chrome/browser/sync/protocol/service_constants.h"
 #include "chrome/browser/sync/syncable/directory_backing_store.h"
 #include "chrome/browser/sync/syncable/directory_change_listener.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "chrome/browser/sync/syncable/syncable-inl.h"
@@ skipping 151 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////
 // EntryKernel
 
 EntryKernel::EntryKernel() : dirty_(false) {
   memset(int64_fields, 0, sizeof(int64_fields));
 }
 
 EntryKernel::~EntryKernel() {}
 
+bool EntryKernel::ContainsString(const std::string& lowercase_query) const {
+  // TODO(lipalani) - figure out what to do if the node is encrypted.
+  const sync_pb::EntitySpecifics& specifics = ref(SPECIFICS);
+  std::string temp;
+  // The protobuf serialized string contains the original strings. So
+  // we will just serialize it and search it.
+  specifics.SerializeToString(&temp);
+
+  // Now convert to lower case.
+  StringToLowerASCII(&temp);
+
+  if (temp.find(lowercase_query) != std::string::npos)
+    return true;
+
+  // Now go through all the string fields to see if the value is there.
+  for (int i = STRING_FIELDS_BEGIN; i < STRING_FIELDS_END; ++i) {
+    std::string value = ref(static_cast<StringField>(i));
+
+    StringToLowerASCII(&value);
+    if (value.find(lowercase_query) != std::string::npos)
+      return true;
+  }
+  return false;
+}
+
 namespace {
 
 // Utility function to loop through a set of enum values and add the
 // field keys/values in the kernel to the given dictionary.
 //
 // V should be convertible to Value.
 template <class T, class U, class V>
 void SetFieldValues(const EntryKernel& kernel,
                     DictionaryValue* dictionary_value,
                     const char* (*enum_key_fn)(T),
@@ skipping 279 matching lines @@
   kernel_->needle.put(META_HANDLE, metahandle);
   MetahandlesIndex::iterator found =
       kernel_->metahandles_index->find(&kernel_->needle);
   if (found != kernel_->metahandles_index->end()) {
     // Found it in memory.  Easy.
     return *found;
   }
   return NULL;
 }
 
-void Directory::GetChildHandles(BaseTransaction* trans, const Id& parent_id,
-                                Directory::ChildHandles* result) {
+void Directory::GetChildHandlesById(
+    BaseTransaction* trans, const Id& parent_id,
+    Directory::ChildHandles* result) {
   CHECK(this == trans->directory());
   result->clear();
-  {
-    ScopedKernelLock lock(this);
 
-    typedef ParentIdChildIndex::iterator iterator;
-    for (iterator i = GetParentChildIndexLowerBound(lock, parent_id),
-                end = GetParentChildIndexUpperBound(lock, parent_id);
-         i != end; ++i) {
-      DCHECK_EQ(parent_id, (*i)->ref(PARENT_ID));
-      result->push_back((*i)->ref(META_HANDLE));
-    }
-  }
+  ScopedKernelLock lock(this);
+  AppendChildHandles(lock, parent_id, result);
+}
+
+void Directory::GetChildHandlesByHandle(
+    BaseTransaction* trans, int64 handle,
+    Directory::ChildHandles* result) {
+  CHECK(this == trans->directory());
+  result->clear();
+
+  ScopedKernelLock lock(this);
+  EntryKernel* kernel = GetEntryByHandle(handle, &lock);
+  if (!kernel)
+    return;
+
+  AppendChildHandles(lock, kernel->ref(ID), result);
 }
 
 EntryKernel* Directory::GetRootEntry() {
   return GetEntryById(Id());
 }
 
 void ZeroFields(EntryKernel* entry, int first_field) {
   int i = first_field;
   // Note that bitset<> constructor sets all bits to zero, and strings
   // initialize to empty.
@@ skipping 404 matching lines @@
   result->clear();
   ScopedKernelLock lock(this);
   MetahandlesIndex::iterator i;
   for (i = kernel_->metahandles_index->begin();
        i != kernel_->metahandles_index->end();
        ++i) {
     result->insert((*i)->ref(META_HANDLE));
   }
 }
 
+void Directory::GetAllEntryKernels(BaseTransaction* trans,
+                                   std::vector<const EntryKernel*>* result) {
+  result->clear();
+  ScopedKernelLock lock(this);
+  result->insert(result->end(),
+                 kernel_->metahandles_index->begin(),
+                 kernel_->metahandles_index->end());
+}
+
 void Directory::GetUnsyncedMetaHandles(BaseTransaction* trans,
                                        UnsyncedMetaHandles* result) {
   result->clear();
   ScopedKernelLock lock(this);
   copy(kernel_->unsynced_metahandles->begin(),
        kernel_->unsynced_metahandles->end(), back_inserter(*result));
 }
 
 int64 Directory::unsynced_entity_count() const {
   ScopedKernelLock lock(this);
@@ skipping 987 matching lines @@
 
 Directory::ParentIdChildIndex::iterator
 Directory::GetParentChildIndexUpperBound(const ScopedKernelLock& lock,
                                          const Id& parent_id) {
   // The upper bound of |parent_id|'s range is the lower
   // bound of |++parent_id|'s range.
   return GetParentChildIndexLowerBound(lock,
       parent_id.GetLexicographicSuccessor());
 }
 
+void Directory::AppendChildHandles(const ScopedKernelLock& lock,
+                                   const Id& parent_id,
+                                   Directory::ChildHandles* result) {
+  typedef ParentIdChildIndex::iterator iterator;
+  CHECK(result);
+  for (iterator i = GetParentChildIndexLowerBound(lock, parent_id),
+           end = GetParentChildIndexUpperBound(lock, parent_id);
+       i != end; ++i) {
+    DCHECK_EQ(parent_id, (*i)->ref(PARENT_ID));
+    result->push_back((*i)->ref(META_HANDLE));
+  }
+}
+
 }  // namespace syncable