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..292aaea9aadbc57536846f78f747a647dfe7089c
--- /dev/null
+++ b/tools/telemetry/telemetry/extension_page.py
@@ -0,0 +1,94 @@
+# 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 util
+
+class ExtensionPage(object):
+  """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, tab):

[nduca, 2012/12/07 19:23:47]

When we get close to landing this, this shouldn't have a tab as much as have the
copy & pasted parts of the tab init code, so this has an inpsector backend,
timeline, runtime but not page probably

+    self.tab = tab
+
+  def __enter__(self):
+    return self
+
+  def __exit__(self, *args):
+    self.tab.Close()
+
+  def _FormatParameters(self, *parameters):
+    json_params = ''
+    for param in parameters:

[nduca, 2012/12/07 19:23:47]

doesn't our code do this for us?

[zel, 2012/12/12 21:03:42]

not sure. what do you think I should be calling instead?

+      if len(json_params) > 0:
+        json_params += ','
+      json_params += json.dumps(param[0])
+
+    return json_params
+
+  def _RegisterEventListeners(self, event_names):
+    self.tab.runtime.Execute('window.__lastCallEventHandler = {};')
+    for event_name in event_names:
+      self.tab.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.tab.runtime.Execute("""
+          %s.removeListener(window.__lastCallEventHandler['%s']);
+        """ % (event_name, event_name))
+
+    self.tab.runtime.Execute('window.__lastCallEventHandler = {};')
+
+  def RunMethodWithEvents(self, event_names, method_name, *parameters):

[nduca, 2012/12/07 19:23:47]

This stuff makes me uneasy that the last argument is the callback. Did you think
about something like

RunJavascriptAndWaitForCallback("myOwnJavaScriptThat.Calls.A.Few.Functions("with",
__TELEMETRY_COMPLETION_CALLBACK, "as some middle argument",
callback_id="__TELEMETRY_COMPLETION_CALLBACK");

Then we could move this to the runtime object

And we could always return the arguments that were passed into the completion
callback, maybe? The distinction between ExecuteJS vs EvaluateJS in the runtime
class might give you a possible design route.

[zel, 2012/12/12 21:03:42]

we need to chat in person about this one too

+    self._RegisterEventListeners(event_names)
+    self.tab.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.tab.runtime.Evaluate(expr)
+
+    util.WaitFor(IsDone, timeout=30)
+    results = (self.tab.runtime.Evaluate('window.__lastCallArguments'),
+               self.tab.runtime.Evaluate('window.__lastCallEventArguments'))
+    self._UnregisterEventListeners(event_names)
+    return results
+
+  def RunMethod(self, method_name, *parameters):
+    self.tab.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.tab.runtime.Evaluate("window.__lastCallDone")
+
+    util.WaitFor(IsDone, timeout=30)
+    return self.tab.runtime.Evaluate("window.__lastCallArguments")
+
+  def RunSyncMethod(self, method_name, *parameters):

[nduca, 2012/12/07 19:23:47]

I think I'm fine with this on runtime object 

+    return self.tab.runtime.Evaluate("%s(%s);" %
+        (method_name, self._FormatParameters(parameters)))
+