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

chrome/browser/sync/syncable/syncable.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 #define CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 #pragma once
 
 #include <algorithm>
 #include <bitset>
@@ skipping 317 matching lines @@
   inline std::string& mutable_ref(StringField field) {
     return string_fields[field - STRING_FIELDS_BEGIN];
   }
   inline sync_pb::EntitySpecifics& mutable_ref(ProtoField field) {
     return specifics_fields[field - PROTO_FIELDS_BEGIN];
   }
   inline Id& mutable_ref(IdField field) {
     return id_fields[field - ID_FIELDS_BEGIN];
   }
 
+  // Does a case in-sensitive search for a given string, which must be
+  // lower case.
+  bool ContainsString(const std::string& lowercase_query) const;
+
   // Dumps all kernel info into a DictionaryValue and returns it.
   // Transfers ownership of the DictionaryValue to the caller.
   DictionaryValue* ToValue() const;
 
  private:
   // Tracks whether this entry needs to be saved to the database.
   bool dirty_;
 };
 
 // A read-only meta entry.
@@ skipping 491 matching lines @@
   struct DirectoryEventTraits {
     typedef DirectoryEvent EventType;
     static inline bool IsChannelShutdownEvent(const DirectoryEvent& event) {
       return DIRECTORY_DESTROYED == event;
     }
   };
  public:
   typedef EventChannel<DirectoryEventTraits, base::Lock> Channel;
   typedef std::vector<int64> ChildHandles;
 
-  // Returns the child meta handles for given parent id.
-  void GetChildHandles(BaseTransaction*, const Id& parent_id,
+  // Returns the child meta handles for given parent id.  Clears
+  // |result| if there are no children.
+  void GetChildHandlesById(BaseTransaction*, const Id& parent_id,
+      ChildHandles* result);
+
+  // Returns the child meta handles for given meta handle.  Clears
+  // |result| if there are no children.
+  void GetChildHandlesByHandle(BaseTransaction*, int64 handle,
       ChildHandles* result);
 
   // Find the first or last child in the positional ordering under a parent,
   // and return its id.  Returns a root Id if parent has no children.
   virtual Id GetFirstChildId(BaseTransaction* trans, const Id& parent_id);
   Id GetLastChildId(BaseTransaction* trans, const Id& parent_id);
 
   // Compute a local predecessor position for |update_item|.  The position
   // is determined by the SERVER_POSITION_IN_PARENT value of |update_item|,
   // as well as the SERVER_POSITION_IN_PARENT values of any up-to-date
   // children of |parent_id|.
   Id ComputePrevIdFromServerPosition(
       const EntryKernel* update_item,
       const syncable::Id& parent_id);
 
   // SaveChanges works by taking a consistent snapshot of the current Directory
   // state and indices (by deep copy) under a ReadTransaction, passing this
   // snapshot to the backing store under no transaction, and finally cleaning
   // up by either purging entries no longer needed (this part done under a
   // WriteTransaction) or rolling back the dirty bits.  It also uses
   // internal locking to enforce SaveChanges operations are mutually exclusive.
   //
   // WARNING: THIS METHOD PERFORMS SYNCHRONOUS I/O VIA SQLITE.
   bool SaveChanges();
 
+  // Fill in |result| with all entry kernels.
+  void GetAllEntryKernels(BaseTransaction* trans,
+                          std::vector<const EntryKernel*>* result);
+
   // Returns the number of entities with the unsynced bit set.
   int64 unsynced_entity_count() const;
 
   // Get GetUnsyncedMetaHandles should only be called after SaveChanges and
   // before any new entries have been created. The intention is that the
   // syncer should call it from its PerformSyncQueries member.
   typedef std::vector<int64> UnsyncedMetaHandles;
   void GetUnsyncedMetaHandles(BaseTransaction* trans,
                               UnsyncedMetaHandles* result);
 
@@ skipping 179 matching lines @@
   ParentIdChildIndex::iterator GetParentChildIndexLowerBound(
       const ScopedKernelLock& lock,
       const Id& parent_id);
 
   // Return an iterator to just past the end of the range of the
   // children of |parent_id| in the kernel's parent_id_child_index.
   ParentIdChildIndex::iterator GetParentChildIndexUpperBound(
       const ScopedKernelLock& lock,
       const Id& parent_id);
 
+  // Append the handles of the children of |parent_id| to |result|.
+  void AppendChildHandles(
+      const ScopedKernelLock& lock,
+      const Id& parent_id, Directory::ChildHandles* result);
+
   Kernel* kernel_;
 
   DirectoryBackingStore* store_;
 };
 
 class ScopedKernelLock {
  public:
   explicit ScopedKernelLock(const Directory*);
   ~ScopedKernelLock() {}
 
@@ skipping 88 matching lines @@
 
 // This is not a reset.  It just sets the numeric fields which are not
 // initialized by the constructor to zero.
 void ZeroFields(EntryKernel* entry, int first_field);
 
 }  // namespace syncable
 
 std::ostream& operator <<(std::ostream&, const syncable::Blob&);
 
 #endif  // CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_