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

chrome/browser/sync/engine/syncapi.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/engine/syncapi.h"
 
 #include <algorithm>
 #include <bitset>
 #include <iomanip>
 #include <list>
+#include <map>
 #include <queue>
 #include <string>
 #include <vector>
 
 #include "base/base64.h"
+#include "base/bind.h"
+#include "base/callback.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/observer_list.h"
 #include "base/sha1.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/synchronization/lock.h"
@@ skipping 297 matching lines @@
 int64 BaseNode::GetFirstChildId() const {
   syncable::Directory* dir = GetTransaction()->GetLookup();
   syncable::BaseTransaction* trans = GetTransaction()->GetWrappedTrans();
   syncable::Id id_string =
       dir->GetFirstChildId(trans, GetEntry()->Get(syncable::ID));
   if (id_string.IsRoot())
     return kInvalidId;
   return IdToMetahandle(GetTransaction()->GetWrappedTrans(), id_string);
 }
 
-DictionaryValue* BaseNode::ToValue() const {
+DictionaryValue* BaseNode::GetSummaryAsValue() const {
   DictionaryValue* node_info = new DictionaryValue();
   node_info->SetString("id", base::Int64ToString(GetId()));
+  node_info->SetBoolean("isFolder", GetIsFolder());
+  // TODO(akalin): Add a std::string accessor for the title.
+  node_info->SetString("title", WideToUTF8(GetTitle()));
+  node_info->Set("type", ModelTypeToValue(GetModelType()));
+  return node_info;
+}
+
+DictionaryValue* BaseNode::GetDetailsAsValue() const {
+  DictionaryValue* node_info = GetSummaryAsValue();
   // TODO(akalin): Return time in a better format.
   node_info->SetString("modificationTime",
                        base::Int64ToString(GetModificationTime()));
   node_info->SetString("parentId", base::Int64ToString(GetParentId()));
-  node_info->SetBoolean("isFolder", GetIsFolder());
-  // TODO(akalin): Add a std::string accessor for the title.
-  node_info->SetString("title", WideToUTF8(GetTitle()));
-  node_info->Set("type", ModelTypeToValue(GetModelType()));
   // Specifics are already in the Entry value, so no need to duplicate
   // it here.
   node_info->SetString("externalId",
                        base::Int64ToString(GetExternalId()));
   node_info->SetString("predecessorId",
                        base::Int64ToString(GetPredecessorId()));
   node_info->SetString("successorId",
                        base::Int64ToString(GetSuccessorId()));
   node_info->SetString("firstChildId",
                        base::Int64ToString(GetFirstChildId()));
@@ skipping 740 matching lines @@
     node_dict->SetString("id", base::Int64ToString(id));
     node_dict->Set("specifics",
                     browser_sync::EntitySpecificsToValue(specifics));
     if (extra.get()) {
       node_dict->Set("extra", extra->ToValue());
     }
     node_value = node_dict;
   } else {
     ReadNode node(trans);
     if (node.InitByIdLookup(id)) {
-      node_value = node.ToValue();
+      node_value = node.GetDetailsAsValue();
     }
   }
   if (!node_value) {
     NOTREACHED();
     node_value = Value::CreateNullValue();
   }
   value->Set("node", node_value);
   return value;
 }
 
-bool BaseNode::ContainsString(const std::string& lowercase_query) const {
-  DCHECK(GetEntry());
-  // TODO(lipalani) - figure out what to do if the node is encrypted.
-  const sync_pb::EntitySpecifics& specifics = GetEntry()->Get(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 = syncable::STRING_FIELDS_BEGIN; i < syncable::STRING_FIELDS_END;
-       ++i) {
-    std::string value = GetEntry()->Get(
-        static_cast<syncable::StringField>(i));
-
-    StringToLowerASCII(&value);
-    if (value.find(lowercase_query) != std::string::npos)
-      return true;
-  }
-  return false;
-}
-
 SyncManager::ExtraPasswordChangeRecordData::ExtraPasswordChangeRecordData() {}
 
 SyncManager::ExtraPasswordChangeRecordData::ExtraPasswordChangeRecordData(
     const sync_pb::PasswordSpecificsData& data)
     : unencrypted_(data) {
 }
 
 SyncManager::ExtraPasswordChangeRecordData::~ExtraPasswordChangeRecordData() {}
 
 DictionaryValue* SyncManager::ExtraPasswordChangeRecordData::ToValue() const {
@@ skipping 64 matching lines @@
         initialized_(false),
         method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
         js_directory_change_listener_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     // Pre-fill |notification_info_map_|.
     for (int i = syncable::FIRST_REAL_MODEL_TYPE;
          i < syncable::MODEL_TYPE_COUNT; ++i) {
       notification_info_map_.insert(
           std::make_pair(syncable::ModelTypeFromInt(i), NotificationInfo()));
     }
+

[lipalani1, 2011/06/02 23:06:39]

This list does not seem to change. So is it possible to just initialize the map
directly and make it a const?

[akalin, 2011/06/02 23:14:58]

As we discussed, C++ isn't expressive enough to do this. :(

+    // Bind message handlers.
+    BindJsMessageHandler(
+        "getNotificationState",
+        &SyncManager::SyncInternal::GetNotificationState);
+    BindJsMessageHandler(
+        "getNotificationInfo",
+        &SyncManager::SyncInternal::GetNotificationInfo);
+    BindJsMessageHandler(
+        "getRootNodeDetails",
+        &SyncManager::SyncInternal::GetRootNodeDetails);
+    BindJsMessageHandler(
+        "getNodeSummariesById",
+        &SyncManager::SyncInternal::GetNodeSummariesById);
+    BindJsMessageHandler(
+        "getNodeDetailsById",
+        &SyncManager::SyncInternal::GetNodeDetailsById);
+    BindJsMessageHandler(
+        "getChildNodeIds",
+        &SyncManager::SyncInternal::GetChildNodeIds);
+    BindJsMessageHandler(
+        "findNodesContainingString",
+        &SyncManager::SyncInternal::FindNodesContainingString);
   }
 
   virtual ~SyncInternal() {
     CHECK(!core_message_loop_);
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   }
 
   bool Init(const FilePath& database_location,
             const std::string& sync_server_and_path,
             int port,
@@ skipping 198 matching lines @@
 
   // JsEventRouter implementation.
   virtual void RouteJsEvent(
       const std::string& name,
       const browser_sync::JsEventDetails& details) OVERRIDE;
   virtual void RouteJsMessageReply(
       const std::string& name,
       const browser_sync::JsArgList& args,
       const browser_sync::JsEventHandler* target) OVERRIDE;
 
-  ListValue* FindNodesContainingString(const std::string& query);
+ private:
+  typedef browser_sync::JsArgList
+      (SyncManager::SyncInternal::*UnboundJsMessageHandler)(
+          const browser_sync::JsArgList&);
+  typedef base::Callback<browser_sync::JsArgList(browser_sync::JsArgList)>
+      JsMessageHandler;
+  typedef std::map<std::string, JsMessageHandler> JsMessageHandlerMap;
 
- private:
   // Helper to call OnAuthError when no authentication credentials are
   // available.
   void RaiseAuthNeededEvent();
 
   // Helper to set initialized_ to true and raise an event to clients to notify
   // that initialization is complete and it is safe to send us changes. If
   // already initialized, this is a no-op.
   void MarkAndNotifyInitializationComplete();
 
   // Sends notifications to peers.
@@ skipping 91 matching lines @@
   // Helper for migration to new nigori proto to set
   // 'using_explicit_passphrase' in the NigoriSpecifics.
   // TODO(tim): Bug 62103.  Remove this after it has been pushed out to dev
   // channel users.
   void SetUsingExplicitPassphrasePrefForMigration(
       WriteTransaction* const trans);
 
   // Checks for server reachabilty and requests a nudge.
   void OnIPAddressChangedImpl();
 
-  // Functions called by ProcessMessage().
-  browser_sync::JsArgList ProcessGetNodesByIdMessage(
+  // Helper function used only by the constructor.
+  void BindJsMessageHandler(
+    const std::string& name,
+    UnboundJsMessageHandler unbound_message_handler);
+
+  // JS message handlers.
+  browser_sync::JsArgList GetNotificationState(
       const browser_sync::JsArgList& args);
 
-  browser_sync::JsArgList ProcessGetChildNodeIdsMessage(
+  browser_sync::JsArgList GetNotificationInfo(
       const browser_sync::JsArgList& args);
 
-  browser_sync::JsArgList ProcessFindNodesContainingString(
+  browser_sync::JsArgList GetRootNodeDetails(
+      const browser_sync::JsArgList& args);
+
+  browser_sync::JsArgList GetNodeSummariesById(
+      const browser_sync::JsArgList& args);
+
+  browser_sync::JsArgList GetNodeDetailsById(
+      const browser_sync::JsArgList& args);
+
+  browser_sync::JsArgList GetChildNodeIds(
+      const browser_sync::JsArgList& args);
+
+  browser_sync::JsArgList FindNodesContainingString(
       const browser_sync::JsArgList& args);
 
   // We couple the DirectoryManager and username together in a UserShare member
   // so we can return a handle to share_ to clients of the API for use when
   // constructing any transaction type.
   UserShare share_;
 
   MessageLoop* core_message_loop_;
 
   ObserverList<SyncManager::Observer> observers_;
@@ skipping 44 matching lines @@
   // True if the SyncManager should be running in test mode (no syncer thread
   // actually communicating with the server).
   bool setup_for_test_mode_;
 
   ScopedRunnableMethodFactory<SyncManager::SyncInternal> method_factory_;
 
   // Map used to store the notification info to be displayed in about:sync page.
   NotificationInfoMap notification_info_map_;
 
   browser_sync::JsDirectoryChangeListener js_directory_change_listener_;
+
+  JsMessageHandlerMap js_message_handlers_;
 };
 const int SyncManager::SyncInternal::kDefaultNudgeDelayMilliseconds = 200;
 const int SyncManager::SyncInternal::kPreferencesNudgeDelayMilliseconds = 2000;
 
 SyncManager::Observer::~Observer() {}
 
 SyncManager::SyncManager() {
   data_ = new SyncInternal(this);
 }
 
@@ skipping 478 matching lines @@
   syncable::FillNigoriEncryptedTypes(newly_encrypted_types, &nigori);
   node.SetNigoriSpecifics(nigori);
 
   // TODO(zea): only reencrypt this datatype? ReEncrypting everything is a
   // safer approach, and should not impact anything that is already encrypted
   // (redundant changes are ignored).
   ReEncryptEverything(&trans);
   return;
 }
 
-namespace {
-
-void FindChildNodesContainingString(const std::string& lowercase_query,
-    const ReadNode& parent_node,
-    sync_api::ReadTransaction* trans,
-    ListValue* result) {
-  int64 child_id = parent_node.GetFirstChildId();
-  while (child_id != kInvalidId) {
-    ReadNode node(trans);
-    if (node.InitByIdLookup(child_id)) {
-      if (node.ContainsString(lowercase_query)) {
-        result->Append(new StringValue(base::Int64ToString(child_id)));
-      }
-      FindChildNodesContainingString(lowercase_query, node, trans, result);
-      child_id = node.GetSuccessorId();
-    } else {
-      LOG(WARNING) << "Lookup of node failed. Id: " << child_id;
-      return;
-    }
-  }
-}
-}  // namespace
-
-// Returned pointer owned by the caller.
-ListValue* SyncManager::SyncInternal::FindNodesContainingString(
-    const std::string& query) {
-  // Convert the query string to lower case to perform case insensitive
-  // searches.
-  std::string lowercase_query = query;
-  StringToLowerASCII(&lowercase_query);
-  ReadTransaction trans(GetUserShare());
-  ReadNode root(&trans);
-  root.InitByRootLookup();
-
-  ListValue* result = new ListValue();
-
-  base::Time start_time = base::Time::Now();
-  FindChildNodesContainingString(lowercase_query, root, &trans, result);
-  base::Time end_time = base::Time::Now();
-
-  base::TimeDelta delta = end_time - start_time;
-  VLOG(1) << "Time taken in milliseconds to search " << delta.InMilliseconds();
-
-  return result;
-}
-
 void SyncManager::SyncInternal::ReEncryptEverything(WriteTransaction* trans) {
   syncable::ModelTypeSet encrypted_types =
       GetEncryptedDataTypes(trans->GetWrappedTrans());
   ModelSafeRoutingInfo routes;
   registrar_->GetModelSafeRoutingInfo(&routes);
   std::string tag;
   for (syncable::ModelTypeSet::iterator iter = encrypted_types.begin();
        iter != encrypted_types.end(); ++iter) {
     if (*iter == syncable::PASSWORDS || routes.count(*iter) == 0)
       continue;
@@ skipping 493 matching lines @@
   }
 
   lookup->RemoveChangeListener(&js_directory_change_listener_);
 }
 
 const browser_sync::JsEventRouter*
     SyncManager::SyncInternal::GetParentJsEventRouter() const {
   return parent_router_;
 }
 
-namespace {
-
-void LogNoRouter(const std::string& name,
-                 const browser_sync::JsArgList& args) {
-  VLOG(1) << "No parent router; not replying to message " << name
-          << " with args " << args.ToString();
-}
-
-}  // namespace
-
 void SyncManager::SyncInternal::ProcessMessage(
     const std::string& name, const browser_sync::JsArgList& args,
     const browser_sync::JsEventHandler* sender) {
   DCHECK(initialized_);
-  if (name == "getNotificationState") {
-    if (!parent_router_) {
-      LogNoRouter(name, args);
-      return;
-    }
-    bool notifications_enabled = allstatus_.status().notifications_enabled;
-    ListValue return_args;
-    return_args.Append(Value::CreateBooleanValue(notifications_enabled));
-    parent_router_->RouteJsMessageReply(
-        name, browser_sync::JsArgList(&return_args), sender);
-  } else if (name == "getNotificationInfo") {
-    if (!parent_router_) {
-      LogNoRouter(name, args);
-      return;
-    }
+  if (!parent_router_) {
+    VLOG(1) << "No parent router; not replying to message " << name
+            << " with args " << args.ToString();
+    return;
+  }
 
-    ListValue return_args;
-    return_args.Append(NotificationInfoToValue(notification_info_map_));
-    parent_router_->RouteJsMessageReply(
-        name, browser_sync::JsArgList(&return_args), sender);
-  } else if (name == "getRootNode") {
-    if (!parent_router_) {
-      LogNoRouter(name, args);
-      return;
-    }
-    ReadTransaction trans(GetUserShare());
-    ReadNode root(&trans);
-    root.InitByRootLookup();
-    ListValue return_args;
-    return_args.Append(root.ToValue());
-    parent_router_->RouteJsMessageReply(
-        name, browser_sync::JsArgList(&return_args), sender);
-  } else if (name == "getNodesById") {
-    if (!parent_router_) {
-      LogNoRouter(name, args);
-      return;
-    }
-    parent_router_->RouteJsMessageReply(
-        name, ProcessGetNodesByIdMessage(args), sender);
-  } else if (name == "getChildNodeIds") {
-    if (!parent_router_) {
-      LogNoRouter(name, args);
-      return;
-    }
-    parent_router_->RouteJsMessageReply(
-        name, ProcessGetChildNodeIdsMessage(args), sender);
-  } else if (name == "findNodesContainingString") {
-    if (!parent_router_) {
-      LogNoRouter(name, args);
-      return;
-    }
-    parent_router_->RouteJsMessageReply(
-        name, ProcessFindNodesContainingString(args), sender);
-  } else {
+  JsMessageHandler js_message_handler = js_message_handlers_[name];
+  if (js_message_handler.is_null()) {
     VLOG(1) << "Dropping unknown message " << name
               << " with args " << args.ToString();
+    return;
   }
+
+  parent_router_->RouteJsMessageReply(
+      name, js_message_handler.Run(args), sender);
 }
 
 void SyncManager::SyncInternal::RouteJsEvent(
     const std::string& name,
     const browser_sync::JsEventDetails& details) {
   if (!parent_router_) {
     return;
   }
   parent_router_->RouteJsEvent(name, details);
 }
 
 void SyncManager::SyncInternal::RouteJsMessageReply(
       const std::string& name,
       const browser_sync::JsArgList& args,
       const browser_sync::JsEventHandler* target) {
   if (!parent_router_) {
     return;
   }
   parent_router_->RouteJsMessageReply(name, args, target);
 }
 
+void SyncManager::SyncInternal::BindJsMessageHandler(
+    const std::string& name,
+    UnboundJsMessageHandler unbound_message_handler) {
+  js_message_handlers_[name] =
+      base::Bind(unbound_message_handler, base::Unretained(this));
+}
+
+browser_sync::JsArgList
+    SyncManager::SyncInternal::GetNotificationState(
+        const browser_sync::JsArgList& args) {
+  bool notifications_enabled = allstatus_.status().notifications_enabled;
+  ListValue return_args;
+  return_args.Append(Value::CreateBooleanValue(notifications_enabled));
+  return browser_sync::JsArgList(&return_args);
+}
+
+browser_sync::JsArgList
+    SyncManager::SyncInternal::GetNotificationInfo(
+        const browser_sync::JsArgList& args) {
+  ListValue return_args;
+  return_args.Append(NotificationInfoToValue(notification_info_map_));
+  return browser_sync::JsArgList(&return_args);
+}
+
+browser_sync::JsArgList
+    SyncManager::SyncInternal::GetRootNodeDetails(
+        const browser_sync::JsArgList& args) {
+  ReadTransaction trans(GetUserShare());
+  ReadNode root(&trans);
+  root.InitByRootLookup();
+  ListValue return_args;
+  return_args.Append(root.GetDetailsAsValue());
+  return browser_sync::JsArgList(&return_args);
+}
+
 namespace {
 
-bool GetId(const ListValue& ids, int i, int64* id) {
+int64 GetId(const ListValue& ids, int i) {
   std::string id_str;
   if (!ids.GetString(i, &id_str)) {
-    return false;
+    return kInvalidId;
   }
-  if (!base::StringToInt64(id_str, id)) {
-    return false;
+  int64 id = kInvalidId;
+  if (!base::StringToInt64(id_str, &id)) {
+    return kInvalidId;
   }
-  if (*id == kInvalidId) {
-    return false;
-  }
-  return true;
+  return id;
 }
 
-}  // namespace
-
-browser_sync::JsArgList SyncManager::SyncInternal::ProcessGetNodesByIdMessage(
-    const browser_sync::JsArgList& args) {
+browser_sync::JsArgList GetNodeInfoById(
+    const browser_sync::JsArgList& args,
+    UserShare* user_share,
+    DictionaryValue* (BaseNode::*info_getter)() const) {
+  CHECK(info_getter);
   ListValue return_args;
-  ListValue* nodes = new ListValue();
-  return_args.Append(nodes);
+  ListValue* node_summaries = new ListValue();
+  return_args.Append(node_summaries);
   ListValue* id_list = NULL;
-  ReadTransaction trans(GetUserShare());
+  ReadTransaction trans(user_share);
   if (args.Get().GetList(0, &id_list)) {
+    CHECK(id_list);
     for (size_t i = 0; i < id_list->GetSize(); ++i) {
-      int64 id = kInvalidId;
-      if (!GetId(*id_list, i, &id)) {
+      int64 id = GetId(*id_list, i);
+      if (id == kInvalidId) {
         continue;
       }
       ReadNode node(&trans);
       if (!node.InitByIdLookup(id)) {
         continue;
       }
-      nodes->Append(node.ToValue());
+      node_summaries->Append((node.*info_getter)());
+    }
+  }
+  return browser_sync::JsArgList(&return_args);
+}
+
+}  // namespace
+
+browser_sync::JsArgList
+    SyncManager::SyncInternal::GetNodeSummariesById(
+        const browser_sync::JsArgList& args) {
+  return GetNodeInfoById(args, GetUserShare(), &BaseNode::GetSummaryAsValue);
+}
+
+browser_sync::JsArgList
+    SyncManager::SyncInternal::GetNodeDetailsById(
+        const browser_sync::JsArgList& args) {
+  return GetNodeInfoById(args, GetUserShare(), &BaseNode::GetDetailsAsValue);
+}
+
+browser_sync::JsArgList SyncManager::SyncInternal::
+    GetChildNodeIds(
+        const browser_sync::JsArgList& args) {
+  ListValue return_args;
+  ListValue* child_ids = new ListValue();
+  return_args.Append(child_ids);
+  int64 id = GetId(args.Get(), 0);
+  if (id != kInvalidId) {
+    ReadTransaction trans(GetUserShare());
+    syncable::Directory::ChildHandles child_handles;
+    trans.GetLookup()->GetChildHandlesByHandle(trans.GetWrappedTrans(),
+                                               id, &child_handles);
+    for (syncable::Directory::ChildHandles::const_iterator it =
+             child_handles.begin(); it != child_handles.end(); ++it) {
+      child_ids->Append(Value::CreateStringValue(
+          base::Int64ToString(*it)));
     }
   }
   return browser_sync::JsArgList(&return_args);
 }
 
 browser_sync::JsArgList SyncManager::SyncInternal::
-    ProcessGetChildNodeIdsMessage(
+    FindNodesContainingString(
         const browser_sync::JsArgList& args) {
-  ListValue return_args;
-  ListValue* child_ids = new ListValue();
-  return_args.Append(child_ids);
-  int64 id = kInvalidId;
-  if (GetId(args.Get(), 0, &id)) {
-    ReadTransaction trans(GetUserShare());
-    ReadNode node(&trans);
-    if (node.InitByIdLookup(id)) {
-      int64 child_id = node.GetFirstChildId();
-      while (child_id != kInvalidId) {
-        ReadNode child_node(&trans);
-        if (!child_node.InitByIdLookup(child_id)) {
-          break;
-        }
-        child_ids->Append(Value::CreateStringValue(
-            base::Int64ToString(child_id)));
-        child_id = child_node.GetSuccessorId();
-      }
-    }
-  }
-  return browser_sync::JsArgList(&return_args);
-}
-
-browser_sync::JsArgList SyncManager::SyncInternal::
-    ProcessFindNodesContainingString(
-    const browser_sync::JsArgList& args) {
   std::string query;
   ListValue return_args;
   if (!args.Get().GetString(0, &query)) {
     return_args.Append(new ListValue());
     return browser_sync::JsArgList(&return_args);
   }
 
-  ListValue* result = FindNodesContainingString(query);
+  // Convert the query string to lower case to perform case insensitive
+  // searches.
+  std::string lowercase_query = query;
+  StringToLowerASCII(&lowercase_query);
+
+  ListValue* result = new ListValue();
   return_args.Append(result);
+
+  ReadTransaction trans(GetUserShare());
+  std::vector<const syncable::EntryKernel*> entry_kernels;
+  trans.GetLookup()->GetAllEntryKernels(trans.GetWrappedTrans(),
+                                        &entry_kernels);
+
+  for (std::vector<const syncable::EntryKernel*>::const_iterator it =
+           entry_kernels.begin(); it != entry_kernels.end(); ++it) {
+    if ((*it)->ContainsString(lowercase_query)) {
+      result->Append(new StringValue(base::Int64ToString(
+          (*it)->ref(syncable::META_HANDLE))));
+    }
+  }
+
   return browser_sync::JsArgList(&return_args);
 }
 
 void SyncManager::SyncInternal::OnNotificationStateChange(
     bool notifications_enabled) {
   VLOG(1) << "P2P: Notifications enabled = "
           << (notifications_enabled ? "true" : "false");
   allstatus_.SetNotificationsEnabled(notifications_enabled);
   if (syncer_thread()) {
     syncer_thread()->set_notifications_enabled(notifications_enabled);
@@ skipping 126 matching lines @@
 void SyncManager::LogUnsyncedItems(int level) const {
   std::vector<int64> unsynced_handles;
   sync_api::ReadTransaction trans(GetUserShare());
   trans.GetWrappedTrans()->directory()->GetUnsyncedMetaHandles(
       trans.GetWrappedTrans(), &unsynced_handles);
 
   for (std::vector<int64>::const_iterator it = unsynced_handles.begin();
        it != unsynced_handles.end(); ++it) {
     ReadNode node(&trans);
     if (node.InitByIdLookup(*it)) {
-      scoped_ptr<DictionaryValue> value(node.ToValue());
+      scoped_ptr<DictionaryValue> value(node.GetDetailsAsValue());
       std::string info;
       base::JSONWriter::Write(value.get(), true, &info);
       VLOG(level) << info;
     }
   }
 }
 
 void SyncManager::TriggerOnNotificationStateChangeForTest(
     bool notifications_enabled) {
   data_->OnNotificationStateChange(notifications_enabled);
 }
 
 void SyncManager::TriggerOnIncomingNotificationForTest(
     const syncable::ModelTypeBitSet& model_types) {
   syncable::ModelTypePayloadMap model_types_with_payloads =
       syncable::ModelTypePayloadMapFromBitSet(model_types,
           std::string());
 
   data_->OnIncomingNotification(model_types_with_payloads);
 }
 
 }  // namespace sync_api