Proof of concept for running extension API stack through dev tools.

tools/telemetry/telemetry/extension_page.py

Index: tools/telemetry/telemetry/extension_page.py
diff --git a/tools/telemetry/telemetry/extension_page.py b/tools/telemetry/telemetry/extension_page.py
new file mode 100644
index 0000000000000000000000000000000000000000..a5a76ed36223042061466673b604b02e9fbb03c1
--- /dev/null
+++ b/tools/telemetry/telemetry/extension_page.py
@@ -0,0 +1,89 @@
+# 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.
+import json
+
+from telemetry import tab
+from telemetry import util
+
+class ExtensionPage(tab.Tab):
+  """Represents a an extension page in the browser
+
+  Provides wrapper functions for running extension APIs as:
+  E.g.:
+      # Evaluates 1+1 in the extensions's javascript context.
+      tab.runtime.Evaluate('1+1')
+  """
+  def __init__(self, browser, inspector_backend):
+    super(ExtensionPage, self).__init__(browser, inspector_backend)
+
+  def _FormatParameters(self, *parameters):
+    json_params = ''
+    for param in parameters:
+      if len(json_params) > 0:
+        json_params += ','
+      json_params += json.dumps(param[0])
+
+    return json_params
+
+  def _RegisterEventListeners(self, event_names):
+    self.runtime.Execute('window.__lastCallEventHandler = {};')
+    for event_name in event_names:
+      self.runtime.Execute("""
+          window.__lastCallEventHandler['%s'] = function() {
+             window.__lastCallEventArguments['%s'] = arguments;
+          };
+          %s.addListener(window.__lastCallEventHandler['%s']);
+        """ % (event_name, event_name, event_name, event_name))
+
+  def _UnregisterEventListeners(self, event_names):
+    for event_name in event_names:
+      self.runtime.Execute("""
+          %s.removeListener(window.__lastCallEventHandler['%s']);
+        """ % (event_name, event_name))
+
+    self.runtime.Execute('window.__lastCallEventHandler = {};')
+
+  def RunMethodWithEvents(self, event_names, method_name, *parameters):
+    self._RegisterEventListeners(event_names)
+    self.runtime.Execute("""
+      window.__lastCallEventArguments = {};
+      window.__lastCallDone = false;
+      window.__lastCallArguments = false;
+      %s(%s, function() {
+           window.__lastCallArguments = arguments;
+           window.__lastCallDone = true;
+      });
+    """ % (method_name, self._FormatParameters(parameters)))
+    def IsDone():
+      expr = 'window.__lastCallDone'
+      for event_name in event_names:
+        expr += " && window.__lastCallEventArguments['%s']" % event_name
+
+      return self.runtime.Evaluate(expr)
+
+    util.WaitFor(IsDone, timeout=30)
+    results = (self.runtime.Evaluate('window.__lastCallArguments'),
+               self.runtime.Evaluate('window.__lastCallEventArguments'))
+    self._UnregisterEventListeners(event_names)
+    return results
+
+  def RunMethod(self, method_name, *parameters):

[nduca, 2012/11/30 08:16:25]

Might try callling this ChromeExtensionsAPI, making it a member on chrome
extension objects, and have it expose directly the chrome extension methods in a
strongly typed way. Then, have the RunMethod stuff be completely private.

[zel, 2012/12/04 03:12:48]

I've been thinking about this as the next step - with exception that strongly
typed interface will be automatically created during build time from extension
API definition files (idl, json). The plan was to push this in another CL after
we land this basic stuff.

+    self.runtime.Execute("""
+      window.__lastCallDone = false;
+      window.__lastCallArguments = false;
+      %s(%s, function() {
+           window.__lastCallArguments = arguments;
+           window.__lastCallDone = true;
+      });
+    """ % (method_name, self._FormatParameters(parameters)))
+    def IsDone():
+      return self.runtime.Evaluate("window.__lastCallDone")
+
+    util.WaitFor(IsDone, timeout=30)
+    return self.runtime.Evaluate("window.__lastCallArguments")
+
+  def RunSyncMethod(self, method_name, *parameters):
+    return self.runtime.Evaluate("%s(%s);" %
+        (method_name, self._FormatParameters(parameters)))
+