Sky should expose services provided to/by embedder

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/engine/config.h"
 #include "sky/viewer/internals.h"
 
 #include "mojo/public/cpp/application/connect.h"
 #include "mojo/public/cpp/bindings/array.h"
 #include "sky/engine/public/web/WebDocument.h"
@@ skipping 26 matching lines @@
 void ContentAsText(Dart_NativeArguments args) {
   Dart_Handle result = StdStringToDart(GetInternals()->ContentAsText());
   Dart_SetReturnValue(args, result);
 }
 
 void NotifyTestComplete(Dart_NativeArguments args) {
   Dart_Handle test_result = Dart_GetNativeArgument(args, 0);
   GetInternals()->NotifyTestComplete(StdStringFromDart(test_result));
 }
 
-void PassShellProxyHandle(Dart_NativeArguments args) {
-  Dart_SetIntegerReturnValue(args, GetInternals()->PassShellProxyHandle().value());
+void TakeShellProxyHandle(Dart_NativeArguments args) {
+  Dart_SetIntegerReturnValue(args,
+      GetInternals()->TakeShellProxyHandle().value());
+}
+
+void TakeServicesProvidedToEmbedder(Dart_NativeArguments args) {
+  Dart_SetIntegerReturnValue(args,
+      GetInternals()->TakeServicesProvidedToEmbedder().value());
+}
+
+void TakeServicesProvidedByEmbedder(Dart_NativeArguments args) {
+  Dart_SetIntegerReturnValue(args,
+      GetInternals()->TakeServicesProvidedByEmbedder().value());
 }
 
 const DartBuiltin::Natives kNativeFunctions[] = {
   {"renderTreeAsText", RenderTreeAsText, 0},
   {"contentAsText", ContentAsText, 0},
   {"notifyTestComplete", NotifyTestComplete, 1},
-  {"passShellProxyHandle", PassShellProxyHandle, 0},
+  {"takeShellProxyHandle", TakeShellProxyHandle, 0},
+  {"takeServicesProvidedToEmbedder", TakeServicesProvidedToEmbedder, 0},
+  {"takeServicesProvidedByEmbedder", TakeServicesProvidedByEmbedder, 0},
 };
 
 const DartBuiltin& GetBuiltin() {
   static DartBuiltin& builtin = *new DartBuiltin(kNativeFunctions,
                                                  arraysize(kNativeFunctions));
   return builtin;
 }
 
 Dart_NativeFunction Resolver(Dart_Handle name,
                              int argument_count,
                              bool* auto_setup_scope) {
   return GetBuiltin().Resolver(name, argument_count, auto_setup_scope);
 }
 
 const uint8_t* Symbolizer(Dart_NativeFunction native_function) {
   return GetBuiltin().Symbolizer(native_function);
 }
 
 const char kLibraryName[] = "dart:sky.internals";
 const char kLibrarySource[] = R"DART(
 String renderTreeAsText() native "renderTreeAsText";
 String contentAsText() native "contentAsText";
 void notifyTestComplete(String test_result) native "notifyTestComplete";
-int passShellProxyHandle() native "passShellProxyHandle";
+int takeShellProxyHandle() native "takeShellProxyHandle";
+int takeServicesProvidedToEmbedder() native "takeServicesProvidedToEmbedder";
+int takeServicesProvidedByEmbedder() native "takeServicesProvidedByEmbedder";
 )DART";
 
 }  // namespace
 
 void Internals::Create(Dart_Isolate isolate, DocumentView* document_view) {
   DartState* state = DartState::From(isolate);
   state->SetUserData(&kInternalsKey, new Internals(document_view));
   Dart_Handle library =
       Dart_LoadLibrary(Dart_NewStringFromCString(kLibraryName),
                        Dart_NewStringFromCString(kLibrarySource), 0, 0);
   CHECK(!LogIfError(library));
   CHECK(!LogIfError(Dart_FinalizeLoading(true)));
   CHECK(!LogIfError(Dart_SetNativeResolver(library, Resolver, Symbolizer)));
 }
 
 Internals::Internals(DocumentView* document_view)
   : document_view_(document_view->GetWeakPtr()),
     shell_binding_(this) {
-  if (document_view_->imported_services())
-    mojo::ConnectToService(document_view_->imported_services(), &test_harness_);
+  test_harness_ = document_view_->TakeTestHarness();
 }
 
 Internals::~Internals() {
 }
 
 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_)
     return std::string();
   return document_view_->web_view()->mainFrame()->contentAsText(
       1024*1024).utf8();
 }
 
 void Internals::NotifyTestComplete(const std::string& test_result) {
   if (!RuntimeFlags::Get().testing())
     return;
   std::vector<unsigned char> pixels;
   document_view_->GetPixelsForTesting(&pixels);
   if (test_harness_) {
     test_harness_->OnTestComplete(test_result,
         mojo::Array<uint8_t>::From(pixels));
   }
 }
 
-mojo::Handle Internals::ConnectToEmbedderService(
-    const std::string& interface_name) {
-  if (!document_view_ || !document_view_->imported_services())
+mojo::Handle Internals::TakeServicesProvidedToEmbedder() {
+  if (!document_view_)
     return mojo::Handle();
+  return document_view_->TakeServicesProvidedToEmbedder().release();
+}
 
-  mojo::MessagePipe pipe;
-  document_view_->imported_services()->ConnectToService(interface_name,
-                                                        pipe.handle1.Pass());
-  return pipe.handle0.release();
+mojo::Handle Internals::TakeServicesProvidedByEmbedder() {
+  if (!document_view_)
+    return mojo::Handle();
+  return document_view_->TakeServicesProvidedByEmbedder().release();
 }
 
 // Returns a MessagePipe handle that's connected to this Shell. The caller
 // owns the handle and is expected to use it to create the JS Application for
 // the DocumentView.
-mojo::Handle Internals::PassShellProxyHandle() {
+mojo::Handle Internals::TakeShellProxyHandle() {
   mojo::ShellPtr shell;
   if (!shell_binding_.is_bound())
     shell_binding_.Bind(GetProxy(&shell));
   return shell.PassMessagePipe().release();
 }
 
 void Internals::ConnectToApplication(
     const mojo::String& application_url,
     mojo::InterfaceRequest<mojo::ServiceProvider> services,
     mojo::ServiceProviderPtr exposed_services) {
@@ skipping 18 matching lines @@
 }
 
 void Internals::pauseAnimations(double pauseTime) {
   if (pauseTime < 0)
     return;
 
     document_view_->web_view()->mainFrame()->document().pauseAnimationsForTesting(pauseTime);
 }
 
 }  // namespace sky