Add full text regex searching to chrome://sync

chrome/browser/sync/internal_api/sync_manager.cc

 // Copyright (c) 2012 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/internal_api/sync_manager.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 147 matching lines @@
     BindJsMessageHandler(
         "getRootNodeDetails",
         &SyncManager::SyncInternal::GetRootNodeDetails);
     BindJsMessageHandler(
         "getNodeSummariesById",
         &SyncManager::SyncInternal::GetNodeSummariesById);
     BindJsMessageHandler(
         "getNodeDetailsById",
         &SyncManager::SyncInternal::GetNodeDetailsById);
     BindJsMessageHandler(
+        "getAllNodes",

[akalin, 2012/03/29 18:41:43]

i think adding a getAllNodes message won't work, because the returned string
will be huge and will be converted multiple times (utf8 -> utf16, etc.).  You
may run out of memory, too.

If you're going to grab all nodes and search them, you can do so by doing
basically a BFS starting with the root node and using getChildNodeIds.  Doing so
will probably be slower, but will take less memory, and may be done
interactively. (Not sure if the current javascript code will already give you
that for free.)

I suggest writing a getAllNodeDetails helper function in javascript which takes
a callback and does the BFS.  Then you can simply call it with a function that
does the querying.

[rlarocque, 2012/03/29 20:51:32]

I understand your concern.  I didn't expect this to work either.  

My test case was a database of over 5000 nodes.  The JSON-serialized result of
GetAllNodes() is 6 million chars long.  

I used the developer tools to take a snapshot of the heap while the search was
in progress.  The heap never exceeded 30MB.  For comparison, a freshly loaded
GMail page is 20MB.  This is my first attempt at using the JavaScript profiler,
so I may be misinterpreting the numbers, but it seems that we can afford to load
all nodes into memory.  

Interactivity/latency is a bit of an issue; see crbug.com/104574 for details. 
For a developers-only interface, though, I think this is acceptable.  

+        &SyncManager::SyncInternal::GetAllNodes);
+    BindJsMessageHandler(
         "getChildNodeIds",
         &SyncManager::SyncInternal::GetChildNodeIds);
-    BindJsMessageHandler(
-        "findNodesContainingString",
-        &SyncManager::SyncInternal::FindNodesContainingString);
   }
 
   virtual ~SyncInternal() {
     CHECK(!initialized_);
   }
 
   bool Init(const FilePath& database_location,
             const WeakHandle<JsEventHandler>& event_handler,
             const std::string& sync_server_and_path,
             int port,
@@ skipping 320 matching lines @@
     const std::string& name, UnboundJsMessageHandler unbound_message_handler);
 
   // Returned pointer is owned by the caller.
   static DictionaryValue* NotificationInfoToValue(
       const NotificationInfoMap& notification_info);
 
   // JS message handlers.
   JsArgList GetNotificationState(const JsArgList& args);
   JsArgList GetNotificationInfo(const JsArgList& args);
   JsArgList GetRootNodeDetails(const JsArgList& args);
+  JsArgList GetAllNodes(const JsArgList& args);
   JsArgList GetNodeSummariesById(const JsArgList& args);
   JsArgList GetNodeDetailsById(const JsArgList& args);
   JsArgList GetChildNodeIds(const JsArgList& args);
-  JsArgList FindNodesContainingString(const JsArgList& args);
 
   FilePath database_path_;
 
   const std::string name_;
 
   base::ThreadChecker thread_checker_;
 
   base::WeakPtrFactory<SyncInternal> weak_ptr_factory_;
 
   // Thread-safe handle used by
@@ skipping 1701 matching lines @@
 JsArgList SyncManager::SyncInternal::GetNodeSummariesById(
     const JsArgList& args) {
   return GetNodeInfoById(args, GetUserShare(), &BaseNode::GetSummaryAsValue);
 }
 
 JsArgList SyncManager::SyncInternal::GetNodeDetailsById(
     const JsArgList& args) {
   return GetNodeInfoById(args, GetUserShare(), &BaseNode::GetDetailsAsValue);
 }
 
+JsArgList SyncManager::SyncInternal::GetAllNodes(
+    const JsArgList& args) {
+  ListValue return_args;
+  ListValue* result = new ListValue();
+  return_args.Append(result);
+
+  ReadTransaction trans(FROM_HERE, GetUserShare());
+  std::vector<const syncable::EntryKernel*> entry_kernels;
+  trans.GetDirectory()->GetAllEntryKernels(trans.GetWrappedTrans(),
+                                           &entry_kernels);
+
+  for (std::vector<const syncable::EntryKernel*>::const_iterator it =
+           entry_kernels.begin(); it != entry_kernels.end(); ++it) {
+    result->Append((*it)->ToValue());

[rlarocque, 2012/03/27 01:49:05]

This returns the JSON-ified node to the JavaScript layer.  It's a bit confusing
because the right-hand pane of the search UI will display the
GetNodeDetailsById() version of the node.  From a user's point of view, it's not
obvious which attributes are part of the search.

+  }
+
+  return JsArgList(&return_args);
+}
+
 JsArgList SyncManager::SyncInternal::GetChildNodeIds(
     const 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(FROM_HERE, GetUserShare());
     syncable::Directory::ChildHandles child_handles;
     trans.GetDirectory()->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 JsArgList(&return_args);
 }
 
-JsArgList SyncManager::SyncInternal::FindNodesContainingString(
-    const JsArgList& args) {
-  std::string query;
-  ListValue return_args;
-  if (!args.Get().GetString(0, &query)) {
-    return_args.Append(new ListValue());
-    return JsArgList(&return_args);
-  }
-
-  // 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(FROM_HERE, GetUserShare());
-  std::vector<const syncable::EntryKernel*> entry_kernels;
-  trans.GetDirectory()->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 JsArgList(&return_args);
-}
-
 void SyncManager::SyncInternal::OnEncryptedTypesChanged(
     syncable::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   // NOTE: We're in a transaction.
   FOR_EACH_OBSERVER(
       SyncManager::Observer, observers_,
       OnEncryptedTypesChanged(encrypted_types, encrypt_everything));
 }
 
 void SyncManager::SyncInternal::OnNotificationStateChange(
@@ skipping 218 matching lines @@
     share->directory->GetDownloadProgress(i.Get(), &marker);
 
     if (marker.token().empty())
       result.Put(i.Get());
 
   }
   return result;
 }
 
 }  // namespace sync_api