Implement ServiceManager

mojo/services/native_viewport/native_viewport_impl.cc

 // Copyright 2013 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 "mojo/services/native_viewport/native_viewport_impl.h"
-
+#include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
+#include "mojo/common/bindings_support_impl.h"
 #include "mojo/services/gles2/gles2_impl.h"
 #include "mojo/services/native_viewport/native_viewport.h"
+#include "mojom/native_viewport.h"
+#include "mojom/shell.h"
 #include "ui/events/event.h"
 
+#if defined(WIN32)
+#if !defined(CDECL)
+#define CDECL __cdecl
+#endif
+#define NATIVE_VIEWPORT_EXPORT __declspec(dllexport)
+#else
+#define CDECL
+#define NATIVE_VIEWPORT_EXPORT __attribute__((visibility("default")))
+#endif
+
 namespace mojo {
 namespace services {
 
-NativeViewportImpl::NativeViewportImpl(shell::Context* context,
-                                       ScopedMessagePipeHandle pipe)
-    : context_(context),
-      widget_(gfx::kNullAcceleratedWidget),
-      client_(pipe.Pass()) {
-  client_.SetPeer(this);
-}
-
-NativeViewportImpl::~NativeViewportImpl() {
-}
-
-void NativeViewportImpl::Open() {
-  native_viewport_ = services::NativeViewport::Create(context_, this);
-  native_viewport_->Init();
-  client_->OnCreated();
-}
-
-void NativeViewportImpl::Close() {
-  DCHECK(native_viewport_);
-  native_viewport_->Close();
-}
-
-void NativeViewportImpl::CreateGLES2Context(
-    ScopedMessagePipeHandle gles2_client) {
-  gles2_.reset(new GLES2Impl(gles2_client.Pass()));
-  CreateGLES2ContextIfNeeded();
-}
-
-void NativeViewportImpl::CreateGLES2ContextIfNeeded() {
-  if (widget_ == gfx::kNullAcceleratedWidget || !gles2_)
-    return;
-  gles2_->CreateContext(widget_, native_viewport_->GetSize());
-}
-
-bool NativeViewportImpl::OnEvent(ui::Event* ui_event) {
-  AllocationScope scope;
-
-  Event::Builder event;
-  event.set_action(ui_event->type());
-  event.set_time_stamp(ui_event->time_stamp().ToInternalValue());
-
-  if (ui_event->IsMouseEvent() || ui_event->IsTouchEvent()) {
-    ui::LocatedEvent* located_event = static_cast<ui::LocatedEvent*>(ui_event);
-    Point::Builder location;
-    location.set_x(located_event->location().x());
-    location.set_y(located_event->location().y());
-    event.set_location(location.Finish());
+class NativeViewportService : public ::shell::ShellClientStub {
+ public:
+  NativeViewportService(ScopedMessagePipeHandle shell_pipe)

[Ben Goodger (Google), 2013/12/10 16:35:03]

indentation is wacky here

[DaveMoore, 2013/12/11 18:56:44]

Done.

+    : shell_(shell_pipe.Pass()) {
+    shell_.SetPeer(this);
   }
 
-  if (ui_event->IsTouchEvent()) {
-    ui::TouchEvent* touch_event = static_cast<ui::TouchEvent*>(ui_event);
-    TouchData::Builder touch_data;
-    touch_data.set_pointer_id(touch_event->touch_id());
-    event.set_touch_data(touch_data.Finish());
+  virtual ~NativeViewportService() {}
+
+  virtual void Connect(ScopedMessagePipeHandle client_pipe) MOJO_OVERRIDE {
+    viewports_.push_back(new NativeViewportImpl(client_pipe.Pass()));

[darin (slow to review), 2013/12/10 06:12:36]

It looks like this vector only grows?

[DaveMoore, 2013/12/11 18:56:44]

It does. We need to have it clean up. But we need some mechanism to make that
happen safely. Right now the error notifications aren't passed out of the
Connectors / RemotePtrs. Leaving a TODO behind.
On 2013/12/10 06:12:36, darin wrote:

   }
 
-  client_->OnEvent(event.Finish());
-  return false;
-}
+ private:
+  class NativeViewportImpl : public NativeViewportStub,

[darin (slow to review), 2013/12/10 06:12:36]

It feels like in a build where NV service is statically linked into mojo_shell
that NativeViewportService would look different, or at least, it wouldn't need
to be a ShellClient implementation.

Perhaps NativeViewportImpl should not be a nested class then, and we should put
the two classes in separate files even? NativeViewportService just seems like
boilerplate code for how a NativeViewportImpl gets instantiated, but otherwise a
NVImpl doesn't really need to know about NVService.

[DaveMoore, 2013/12/11 18:56:44]

I think it will be a ShellClient implementation, as it still talks to the Shell,
it just isn't loaded from a .so.

 Right now it does know about the service itself, because it keeps track of the
extant instances. it's possible we'll have some library or template support for
a Service that vends the connections generically.

On 2013/12/10 06:12:36, darin wrote:

+                             public NativeViewportDelegate {
+   public:
+    NativeViewportImpl(ScopedMessagePipeHandle client_pipe)
+        : widget_(gfx::kNullAcceleratedWidget),
+          client_(client_pipe.Pass()) {
+      client_.SetPeer(this);
+    }
+    virtual ~NativeViewportImpl() {}
 
-void NativeViewportImpl::OnAcceleratedWidgetAvailable(
-    gfx::AcceleratedWidget widget) {
-  widget_ = widget;
-  CreateGLES2ContextIfNeeded();
-}
+    virtual void Open() MOJO_OVERRIDE {
+      native_viewport_ = services::NativeViewport::Create(this);
+      native_viewport_->Init();
+      client_->OnCreated();
+    }
 
-void NativeViewportImpl::OnResized(const gfx::Size& size) {
-}
+    virtual void Close() MOJO_OVERRIDE {
+      gles2_.reset();
+      DCHECK(native_viewport_);
+      native_viewport_->Close();
+    }
 
-void NativeViewportImpl::OnDestroyed() {
-  // TODO(beng):
-  // Destroying |gles2_| on the shell thread here hits thread checker asserts.
-  // All code must stop touching the AcceleratedWidget at this point as it is
-  // dead after this call stack. jamesr said we probably should make our own
-  // GLSurface and simply tell it to stop touching the AcceleratedWidget
-  // via Destroy() but we have no good way of doing that right now given our
-  // current threading model so james' recommendation was just to wait until
-  // after we move the gl service out of process.
-  // gles2_.reset();
-  client_->OnDestroyed();
-}
+    virtual void CreateGLES2Context(ScopedMessagePipeHandle gles2_client)
+        MOJO_OVERRIDE {
+      gles2_.reset(new GLES2Impl(gles2_client.Pass()));
+      CreateGLES2ContextIfNeeded();
+    }
+
+    void CreateGLES2ContextIfNeeded() {
+      if (widget_ == gfx::kNullAcceleratedWidget || !gles2_)
+        return;
+      gles2_->CreateContext(widget_, native_viewport_->GetSize());
+    }
+
+    virtual bool OnEvent(ui::Event* ui_event) MOJO_OVERRIDE {
+      AllocationScope scope;
+
+      Event::Builder event;
+      event.set_action(ui_event->type());
+      event.set_time_stamp(ui_event->time_stamp().ToInternalValue());
+
+      if (ui_event->IsMouseEvent() || ui_event->IsTouchEvent()) {
+        ui::LocatedEvent* located_event =
+            static_cast<ui::LocatedEvent*>(ui_event);
+        Point::Builder location;
+        location.set_x(located_event->location().x());
+        location.set_y(located_event->location().y());
+        event.set_location(location.Finish());
+      }
+
+      if (ui_event->IsTouchEvent()) {
+        ui::TouchEvent* touch_event = static_cast<ui::TouchEvent*>(ui_event);
+        TouchData::Builder touch_data;
+        touch_data.set_pointer_id(touch_event->touch_id());
+        event.set_touch_data(touch_data.Finish());
+      }
+
+      client_->OnEvent(event.Finish());
+      return false;
+    }
+
+    virtual void OnAcceleratedWidgetAvailable(
+        gfx::AcceleratedWidget widget) MOJO_OVERRIDE {
+      widget_ = widget;
+      CreateGLES2ContextIfNeeded();
+    }
+
+    virtual void OnResized(const gfx::Size& size) MOJO_OVERRIDE {
+    }
+
+    virtual void OnDestroyed() MOJO_OVERRIDE {
+      base::MessageLoop::current()->Quit();
+    }
+
+   private:
+    gfx::AcceleratedWidget widget_;
+    scoped_ptr<services::NativeViewport> native_viewport_;
+    scoped_ptr<GLES2Impl> gles2_;
+
+    RemotePtr<NativeViewportClient> client_;
+  };
+  mojo::RemotePtr<::shell::Shell> shell_;
+  ScopedVector<NativeViewportImpl> viewports_;
+};
 
 }  // namespace services
 }  // namespace mojo
+
+extern "C" NATIVE_VIEWPORT_EXPORT MojoResult CDECL MojoMain(

[darin (slow to review), 2013/12/10 06:12:36]

I'm confused about seeing a MojoMain for the NV service as I expected this to be
a service that is built into the mojo_shell. We can only have one MojoMain
symbol for the mojo_shell executable. Is the idea to eventually add some
#ifdef'd code here for statically linked builds?

[Ben Goodger (Google), 2013/12/10 16:35:03]

Also what's the plan here for Android?

[DaveMoore, 2013/12/11 18:56:44]

I think once we add support for statically linked services we'll need to deal
with this in general (although in this case we might decide that we never call a
main() because it always gets created with a message loop). Perhaps we should
make it name determined by the name of the module, or even a static class method
so we don't risk running into name collisions. Then it can exist w/out #defines
around it (although that's still an option).

On 2013/12/10 06:12:36, darin wrote:

[DaveMoore, 2013/12/11 18:56:44]

We're going to create this with a messageloop  and whatever other context is
needed.
On 2013/12/10 16:35:03, Ben Goodger (Google) wrote:

+    const MojoHandle shell_handle) {
+  mojo::common::BindingsSupportImpl bindings_support_impl;
+  mojo::BindingsSupport::Set(&bindings_support_impl);
+
+  mojo::ScopedMessagePipeHandle shell_pipe;
+  shell_pipe.reset(mojo::MessagePipeHandle(shell_handle));
+
+  base::MessageLoop loop(base::MessageLoop::TYPE_UI);
+  mojo::services::NativeViewportService app(
+      mojo::MakeScopedHandle(mojo::MessagePipeHandle(shell_handle)).Pass());
+  base::MessageLoop::current()->Run();
+
+  mojo::BindingsSupport::Set(NULL);
+  return MOJO_RESULT_OK;
+}