Gets HTMLIFrameElement::embedViewManagerClient to work with dart

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 11 matching lines @@
 namespace sky {
 namespace {
 
 int kInternalsKey = 0;
 
 Internals* GetInternals() {
   DartState* state = DartState::Current();
   return static_cast<Internals*>(state->GetUserData(&kInternalsKey));
 }
 
-void RenderTreeAsText(Dart_NativeArguments args) {
-  Dart_Handle result = StdStringToDart(GetInternals()->RenderTreeAsText());
-  Dart_SetReturnValue(args, result);
+void ConnectToService(Dart_NativeArguments args) {
+  Dart_Handle application_url_handle = Dart_GetNativeArgument(args, 0);
+  Dart_Handle interface_name_handle = Dart_GetNativeArgument(args, 1);
+  mojo::ScopedMessagePipeHandle handle(GetInternals()->ConnectToService(
+      StdStringFromDart(application_url_handle),
+      StdStringFromDart(interface_name_handle)));
+  Dart_SetReturnValue(
+      args,
+      DartConverter<mojo::ScopedMessagePipeHandle>::ToDart(handle.Pass()));

[abarth-chromium, 2015/02/23 22:29:38]

You should add a SetReturnValue function to
DartConverter<mojo::ScopedMessagePipeHandle>

 }
 
 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 RenderTreeAsText(Dart_NativeArguments args) {

[sky, 2015/02/23 22:09:33]

I reorder these to be be alphabetical. I can easily undo this part if you think
alphabetizing is worth it here.

[abarth-chromium, 2015/02/23 22:29:38]

That's great, thanks!

+  Dart_Handle result = StdStringToDart(GetInternals()->RenderTreeAsText());
+  Dart_SetReturnValue(args, result);
+}
+
 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());
 }
 
-void TakeServicesProvidedByEmbedder(Dart_NativeArguments args) {
-  Dart_SetIntegerReturnValue(args,
-      GetInternals()->TakeServicesProvidedByEmbedder().value());
+void TakeServicesProvidedToEmbedder(Dart_NativeArguments args) {
+  Dart_SetIntegerReturnValue(
+      args, GetInternals()->TakeServicesProvidedToEmbedder().value());
 }
 
 const DartBuiltin::Natives kNativeFunctions[] = {
-  {"renderTreeAsText", RenderTreeAsText, 0},
-  {"contentAsText", ContentAsText, 0},
-  {"notifyTestComplete", NotifyTestComplete, 1},
-  {"takeShellProxyHandle", TakeShellProxyHandle, 0},
-  {"takeServicesProvidedToEmbedder", TakeServicesProvidedToEmbedder, 0},
-  {"takeServicesProvidedByEmbedder", TakeServicesProvidedByEmbedder, 0},
+    {"connectToService", ConnectToService, 2},

[abarth-chromium, 2015/02/23 22:29:37]

Why do you need connectToService?  Can't you just use the shell handle to do
that?  For example, embedder.connectToService(...) from embedder.dart ?

[sky, 2015/02/23 22:38:56]

That can certainly be done. I was assuming we wanted
Internals::ConnectToService() since this class exposes it already and that is
what the test had been using. Which do you prefer?

+    {"contentAsText", ContentAsText, 0},
+    {"notifyTestComplete", NotifyTestComplete, 1},
+    {"renderTreeAsText", RenderTreeAsText, 0},
+    {"takeShellProxyHandle", TakeShellProxyHandle, 0},
+    {"takeServicesProvidedByEmbedder", TakeServicesProvidedByEmbedder, 0},
+    {"takeServicesProvidedToEmbedder", TakeServicesProvidedToEmbedder, 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";
+int connectToService(String application_url, String interface_name) native
+    "connectToService";
 String contentAsText() native "contentAsText";
 void notifyTestComplete(String test_result) native "notifyTestComplete";
+String renderTreeAsText() native "renderTreeAsText";
 int takeShellProxyHandle() native "takeShellProxyHandle";
+int takeServicesProvidedByEmbedder() native "takeServicesProvidedByEmbedder";
 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);
@@ skipping 60 matching lines @@
 void Internals::ConnectToApplication(
     const mojo::String& application_url,
     mojo::InterfaceRequest<mojo::ServiceProvider> services,
     mojo::ServiceProviderPtr exposed_services) {
   if (document_view_) {
     document_view_->shell()->ConnectToApplication(
         application_url, services.Pass(), exposed_services.Pass());
   }
 }
 
-mojo::Handle Internals::ConnectToService(
-    const std::string& application_url, const std::string& interface_name) {
+mojo::ScopedMessagePipeHandle Internals::ConnectToService(
+    const std::string& application_url,
+    const std::string& interface_name) {
   if (!document_view_)
-    return mojo::Handle();
+    return mojo::ScopedMessagePipeHandle();
 
   mojo::ServiceProviderPtr service_provider;
   ConnectToApplication(application_url, mojo::GetProxy(&service_provider),
                        nullptr);
 
   mojo::MessagePipe pipe;
   service_provider->ConnectToService(interface_name, pipe.handle1.Pass());
-  return pipe.handle0.release();
+  return pipe.handle0.Pass();
 }
 
 void Internals::pauseAnimations(double pauseTime) {
   if (pauseTime < 0)
     return;
 
     document_view_->web_view()->mainFrame()->document().pauseAnimationsForTesting(pauseTime);
 }
 
 }  // namespace sky