[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 829 matching lines @@
     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,
+  void GetChildHandlesById(BaseTransaction*, const Id& parent_id,
+      ChildHandles* result);
+
+  // Returns the child meta handles for given meta handle.
+  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 meta handles.
+  void GetAllMetaHandles(BaseTransaction* trans, MetahandleSet* 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 49 matching lines @@
 
   // Rolls back dirty bits in the event that the SaveChanges that
   // processed |snapshot| failed, for example, due to no disk space.
   void HandleSaveChangesFailure(const SaveChangesSnapshot& snapshot);
 
   // For new entry creation only
   void InsertEntry(EntryKernel* entry, ScopedKernelLock* lock);
   void InsertEntry(EntryKernel* entry);
 
   // Used by CheckTreeInvariants
-  void GetAllMetaHandles(BaseTransaction* trans, MetahandleSet* result);
   bool SafeToPurgeFromMemory(const EntryKernel* const entry) const;
 
   // Internal setters that do not acquire a lock internally.  These are unsafe
   // on their own; caller must guarantee exclusive access manually by holding
   // a ScopedKernelLock.
   void set_initial_sync_ended_for_type_unsafe(ModelType type, bool x);
   void SetNotificationStateUnsafe(const std::string& notification_state);
 
   Directory& operator = (const Directory&);
 
@@ skipping 109 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);
 
+  // Fill in |result| with the handles of the children of |parent_id|.
+  void GetChildHandles(
+      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_