Mojo JS Bindings: merge Application, Shell, ServiceProvider with Sky

sky/viewer/internals.cc

 // Copyright 2014 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 "sky/viewer/internals.h"
 
 #include "mojo/edk/js/core.h"
 #include "mojo/edk/js/handle.h"
 #include "mojo/edk/js/support.h"
+#include "mojo/edk/js/threading.h"
 #include "mojo/public/cpp/application/connect.h"
 #include "mojo/public/cpp/bindings/array.h"
 #include "mojo/public/interfaces/application/shell.mojom.h"
 #include "sky/engine/public/web/WebDocument.h"
 #include "sky/engine/public/web/WebFrame.h"
 #include "sky/engine/public/web/WebView.h"
 #include "sky/viewer/document_view.h"
 #include "v8/include/v8.h"
 #include <limits>
 
 namespace sky {
 
 gin::WrapperInfo Internals::kWrapperInfo = {gin::kEmbedderNativeGin};
 
+class JSShellProxy : public mojo::Shell {
+ public: 
+  JSShellProxy(mojo::ScopedMessagePipeHandle handle, Internals* internals) 
+      : internals_(internals),
+        binding_(this, handle.Pass()) {
+  }
+
+  void ConnectToApplication(
+      const mojo::String& application_url, 
+      mojo::InterfaceRequest<mojo::ServiceProvider> provider) override {
+    if (internals_->document_view_) {
+      mojo::Shell* shell = internals_->document_view_->shell();
+      shell->ConnectToApplication(application_url, provider.Pass());
+    }
+  }
+
+ private:
+  Internals* internals_;
+  mojo::Binding<mojo::Shell> binding_;
+};
+
 // static
 gin::Handle<Internals> Internals::Create(
     v8::Isolate* isolate, DocumentView* document_view) {
   gin::Handle<Internals> internals =
       gin::CreateHandle(isolate, new Internals(document_view));
   v8::Handle<v8::Object> object = internals.ToV8().As<v8::Object>();
   object->Set(gin::StringToV8(isolate, "core"),
               mojo::js::Core::GetModule(isolate));
   object->Set(gin::StringToV8(isolate, "support"),
               mojo::js::Support::GetModule(isolate));
+  object->Set(gin::StringToV8(isolate, "threading"),
+              mojo::js::Threading::GetModule(isolate));
   return internals;
 }
 
 Internals::Internals(DocumentView* document_view)
     : document_view_(document_view->GetWeakPtr()) {
   mojo::ConnectToService(document_view->imported_services(), &test_harness_);
 }
 
 Internals::~Internals() {
+  for (unsigned i = 0; i < js_shell_proxies_.size(); i++)
+    delete js_shell_proxies_[i];
 }
 
 gin::ObjectTemplateBuilder Internals::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   return Wrappable<Internals>::GetObjectTemplateBuilder(isolate)
       .SetMethod("renderTreeAsText", &Internals::RenderTreeAsText)
       .SetMethod("contentAsText", &Internals::ContentAsText)
       .SetMethod("notifyTestComplete", &Internals::NotifyTestComplete)
       .SetMethod("connectToService", &Internals::ConnectToService)
-      .SetMethod("pauseAnimations", &Internals::pauseAnimations);
+      .SetMethod("pauseAnimations", &Internals::pauseAnimations)
+      .SetMethod("shellProxyHandle", &Internals::ShellProxyHandle);
+}
+
+// Returns a MessagePipe handle that's connected to a JSShellProxy. The caller
+// owns the handle.
+mojo::Handle Internals::ShellProxyHandle() {
+    mojo::MessagePipe pipe;
+    if (document_view_)
+      js_shell_proxies_.push_back(new JSShellProxy(pipe.handle0.Pass(), this));
+    return pipe.handle1.release();

[abarth-chromium, 2015/01/07 22:52:01]

Hum...  Can we return the same JS object each time?  It's wasteful for this
function to actually be a factory...  Can't we just hold onto the v8::Handle for
the mojo::Handle and keep returning it?  Then we'd only need one JSShellProxy.

[hansmuller1, 2015/01/07 23:33:04]

This one-time method is now called passProxyHandle(), like InterfacePtr's
PassMessagePipe().  Subsequent calls just return a disconnected MessagePipe
handle.

 }
 
 std::string Internals::RenderTreeAsText() {
   if (!document_view_)
     return std::string();
   return document_view_->web_view()->mainFrame()->renderTreeAsText().utf8();
 }
 
 std::string Internals::ContentAsText() {
   if (!document_view_)
@@ skipping 24 matching lines @@
 }
 
 void Internals::pauseAnimations(double pauseTime) {
   if (pauseTime < 0)
     return;
 
     document_view_->web_view()->mainFrame()->document().pauseAnimationsForTesting(pauseTime);
 }
 
 }  // namespace sky