sync: Remove some WebUI debug functions

sync/syncable/directory.cc

 // Copyright 2013 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 "sync/syncable/directory.h"
 
 #include <iterator>
 
 #include "base/base64.h"
 #include "base/debug/trace_event.h"
@@ skipping 253 matching lines @@
   if (!SyncAssert(this == trans->directory(), FROM_HERE,
                   "Directories don't match", trans))
     return false;
   result->clear();
 
   ScopedKernelLock lock(this);
   AppendChildHandles(lock, parent_id, result);
   return true;
 }
 
-bool Directory::GetChildHandlesByHandle(
-    BaseTransaction* trans, int64 handle,
-    Directory::Metahandles* result) {
-  if (!SyncAssert(this == trans->directory(), FROM_HERE,
-                  "Directories don't match", trans))
-    return false;
-
-  result->clear();
-
-  ScopedKernelLock lock(this);
-  EntryKernel* kernel = GetEntryByHandle(handle, &lock);
-  if (!kernel)
-    return true;
-
-  AppendChildHandles(lock, kernel->ref(ID), result);
-  return true;
-}
-
 int Directory::GetTotalNodeCount(
     BaseTransaction* trans,
     EntryKernel* kernel) const {
   if (!SyncAssert(this == trans->directory(), FROM_HERE,
                   "Directories don't match", trans))
     return false;
 
   int count = 1;
   std::deque<const OrderedChildSet*> child_sets;
 
@@ skipping 578 matching lines @@
 void Directory::GetAllMetaHandles(BaseTransaction* trans,
                                   MetahandleSet* result) {
   result->clear();
   ScopedKernelLock lock(this);
   for (MetahandlesMap::iterator i = kernel_->metahandles_map.begin();
        i != kernel_->metahandles_map.end(); ++i) {
     result->insert(i->first);
   }
 }
 
-void Directory::GetAllEntryKernels(BaseTransaction* trans,
-                                   std::vector<const EntryKernel*>* result) {
-  result->clear();
-  ScopedKernelLock lock(this);
-  for (MetahandlesMap::iterator i = kernel_->metahandles_map.begin();
-       i != kernel_->metahandles_map.end(); ++i) {
-    result->push_back(i->second);
-  }
-}
-
 void Directory::GetUnsyncedMetaHandles(BaseTransaction* trans,
                                        Metahandles* 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 30 matching lines @@
   for (MetahandlesMap::iterator it = kernel_->metahandles_map.begin();
        it != kernel_->metahandles_map.end(); ++it) {
     EntryKernel* entry = it->second;
     const ModelType type = GetModelTypeFromSpecifics(entry->ref(SPECIFICS));
     (*num_entries_by_type)[type]++;
     if (entry->ref(IS_DEL))
       (*num_to_delete_entries_by_type)[type]++;
   }
 }
 
+scoped_ptr<base::ListValue> Directory::GetAllNodeDetails(
+    BaseTransaction* trans) {
+  scoped_ptr<base::ListValue> nodes(new base::ListValue());
+
+  ScopedKernelLock lock(this);
+  for (MetahandlesMap::iterator it = kernel_->metahandles_map.begin();
+       it != kernel_->metahandles_map.end(); ++it) {
+    EntryKernel* kernel = it->second;
+    scoped_ptr<base::DictionaryValue> node(
+        kernel->ToValue(GetCryptographer(trans)));
+
+    // Add the position index if appropriate.  This must be done here (and not
+    // in EntryKernel) because the EntryKernel does not have access to its
+    // siblings.
+    if (kernel->ShouldMaintainPosition() && !kernel->ref(IS_DEL)) {
+      node->SetInteger("positionIndex", GetPositionIndex(trans, kernel));
+    }
+
+    nodes->Append(node.release());
+  }
+
+  return nodes.Pass();
+}
+
 bool Directory::CheckInvariantsOnTransactionClose(
     syncable::BaseTransaction* trans,
     const MetahandleSet& modified_handles) {
   // NOTE: The trans may be in the process of being destructed.  Be careful if
   // you wish to call any of its virtual methods.
   switch (invariant_check_level_) {
     case FULL_DB_VERIFICATION: {
       MetahandleSet all_handles;
       GetAllMetaHandles(trans, &all_handles);
       return CheckTreeInvariants(trans, all_handles);
@@ skipping 327 matching lines @@
 
   for (OrderedChildSet::const_iterator i = children->begin();
        i != children->end(); ++i) {
     DCHECK_EQ(parent_id, (*i)->ref(PARENT_ID));
     result->push_back((*i)->ref(META_HANDLE));
   }
 }
 
 }  // namespace syncable
 }  // namespace syncer