Replace 'descriptionStyles' in omnibox API with a simple xml

chrome/renderer/resources/extension_process_bindings.js

 // Copyright (c) 2010 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.
 
 // This script contains privileged chrome extension related javascript APIs.
 // It is loaded by pages whose URL has the chrome-extension protocol.
 
 var chrome = chrome || {};
 (function() {
   native function GetExtensionAPIDefinition();
@@ skipping 267 matching lines @@
         // if there is one.
         var id = arguments[0].menuItemId;
         var onclick = chromeHidden.contextMenus.handlers[id];
         if (onclick) {
           onclick.apply(null, arguments);
         }
       });
     };
   }
 
+  // Parses the xml syntax supported by omnibox suggestion results. Returns an
+  // object with two properties: 'description', which is just the text content,
+  // and 'descriptionStyles', which is an array of style objects in a format
+  // understood by the C++ backend.
+  function parseOmniboxDescription(input) {
+    var domParser = new DOMParser();
+
+    // The XML parser requires a single top-level element, but we want to
+    // support things like 'hello, <match>world</match>!'. So we wrap the
+    // provided text in generated root level element.
+    var root = domParser.parseFromString(
+        '<fragment>' + input + '</fragment>', 'text/xml');
+
+    // DOMParser has a terrible error reporting facility. Errors come out nested
+    // inside the returned document.
+    var error = root.querySelector('parsererror div');
+    if (error) {
+      throw new Error(error.textContent);
+    }
+
+    // Otherwise, it's valid, so build up the result.
+    var result = {
+      description: '',
+      descriptionStyles: []
+    };
+
+    // Recursively walk the tree.
+    (function(node) {
+      for (var i = 0, child; child = node.childNodes[i]; i++) {
+        // Append text nodes to our description.
+        if (child.nodeType == Node.TEXT_NODE) {
+          result.description += child.nodeValue;
+          continue;
+        }
+
+        // Process and descend into a subset of recognized tags.
+        if (child.nodeType == Node.ELEMENT_NODE &&
+            (child.nodeName == 'dim' || child.nodeName == 'match' ||
+             child.nodeName == 'url')) {
+          var style = {
+            'type': child.nodeName,
+            'offset': result.description.length
+          };
+          result.descriptionStyles.push(style);
+          arguments.callee(child);
+          style.length = result.description.length - style.offset;
+          continue;
+        }
+
+        // Descend into all other nodes, even if they are unrecognized, for
+        // forward compat.
+        arguments.callee(child);
+      }
+    })(root);
+
+    return result;
+  }
+
   function setupOmniboxEvents(extensionId) {
     chrome.omnibox.onInputChanged.dispatch =
         function(text, requestId) {
       var suggestCallback = function(suggestions) {
         chrome.omnibox.sendSuggestions(requestId, suggestions);
       };
       chrome.Event.prototype.dispatch.apply(this, [text, suggestCallback]);
     };
   }
 
@@ skipping 39 matching lines @@
           if (module[functionDef.name])
             return;
 
           var apiFunction = {};
           apiFunction.definition = functionDef;
           apiFunction.name = apiDef.namespace + "." + functionDef.name;
           apiFunctions[apiFunction.name] = apiFunction;
 
           module[functionDef.name] = (function() {
             var args = arguments;
-            if (this.updateArguments) {
-              // Functions whose signature has changed can define an
-              // |updateArguments| function to transform old argument lists
-              // into the new form, preserving compatibility.
-              // TODO(skerner): Once optional args can be omitted (crbug/29215),
-              // this mechanism will become unnecessary.  Consider removing it
-              // when crbug/29215 is fixed.
-              args = this.updateArguments.apply(this, args);
-            }
+            if (this.updateArgumentsPreValidate)
+              args = this.updateArgumentsPreValidate.apply(this, args);
             chromeHidden.validate(args, this.definition.parameters);
+            if (this.updateArgumentsPostValidate)
+              args = this.updateArgumentsPostValidate.apply(this, args);
 
             var retval;
             if (this.handleRequest) {
               retval = this.handleRequest.apply(this, args);
             } else {
               retval = sendRequest(this.name, args,
                                    this.definition.parameters,
                                    this.customCallback);
             }
 
@@ skipping 266 matching lines @@
     apiFunctions["contextMenus.create"].handleRequest =
         function() {
       var args = arguments;
       var id = chromeHidden.contextMenus.nextId++;
       args[0].generatedId = id;
       sendRequest(this.name, args, this.definition.parameters,
                   this.customCallback);
       return id;
     };
 
+    apiFunctions["omnibox.setDefaultSuggestion"].handleRequest =
+        function(details) {
+      var parseResult = parseOmniboxDescription(details.description);
+      sendRequest(this.name, [parseResult], this.definition.parameters);
+    };
+
     apiFunctions["contextMenus.create"].customCallback =
         function(name, request, response) {
       if (chrome.extension.lastError) {
         return;
       }
 
       var id = request.args[0].generatedId;
 
       // Set up the onclick handler if we were passed one in the request.
       var onclick = request.args.length ? request.args[0].onclick : null;
@@ skipping 24 matching lines @@
     };
 
     apiFunctions["contextMenus.removeAll"].customCallback =
         function(name, request, response) {
       if (chrome.extension.lastError) {
         return;
       }
       chromeHidden.contextMenus.handlers = {};
     };
 
-    apiFunctions["tabs.captureVisibleTab"].updateArguments = function() {
+    apiFunctions["tabs.captureVisibleTab"].updateArgumentsPreValidate =
+        function() {
       // Old signature:
       //    captureVisibleTab(int windowId, function callback);
       // New signature:
       //    captureVisibleTab(int windowId, object details, function callback);
       //
       // TODO(skerner): The next step to omitting optional arguments is the
       // replacement of this code with code that matches arguments by type.
       // Once this is working for captureVisibleTab() it can be enabled for
       // the rest of the API. See crbug/29215 .
       if (arguments.length == 2 && typeof(arguments[1]) == "function") {
         // If the old signature is used, add a null details object.
         newArgs = [arguments[0], null, arguments[1]];
       } else {
         newArgs = arguments;
       }
       return newArgs;
     };
 
-    apiFunctions["omnibox.styleUrl"].handleRequest = function(offset, length) {
-      return {type: "url", offset: offset, length: length};
-    };
-    apiFunctions["omnibox.styleMatch"].handleRequest =
-        function(offset, length) {
-      return {type: "match", offset: offset, length: length};
-    };
-    apiFunctions["omnibox.styleDim"].handleRequest = function(offset, length) {
-      return {type: "dim", offset: offset, length: length};
+    apiFunctions["omnibox.sendSuggestions"].updateArgumentsPostValidate =
+        function(requestId, userSuggestions) {
+      var suggestions = [];
+      for (var i = 0; i < userSuggestions.length; i++) {
+        var parseResult = parseOmniboxDescription(
+            userSuggestions[i].description);
+        parseResult.content = userSuggestions[i].content;
+        suggestions.push(parseResult);
+      }
+      return [requestId, suggestions];
     };
 
     if (chrome.test) {
       chrome.test.getApiDefinitions = GetExtensionAPIDefinition;
     }
 
     setupPageActionEvents(extensionId);
     setupToolstripEvents(GetRenderViewId());
     setupPopupEvents(GetRenderViewId());
     setupHiddenContextMenuEvent(extensionId);
     setupOmniboxEvents(extensionId);
   });
 
   if (!chrome.experimental)
     chrome.experimental = {};
 
   if (!chrome.experimental.accessibility)
     chrome.experimental.accessibility = {};
 
   if (!chrome.experimental.tts)
     chrome.experimental.tts = {};
 })();