Mojo: abstract interface implementation from generated Stub classes

mojo/services/native_viewport/native_viewport_service.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_service.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/time/time.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 "ui/events/event.h"
 
 namespace mojo {
 namespace services {
 namespace {
 
 bool IsRateLimitedEventType(ui::Event* event) {
   return event->type() == ui::ET_MOUSE_MOVED ||
          event->type() == ui::ET_MOUSE_DRAGGED ||
          event->type() == ui::ET_TOUCH_MOVED;
 }
 
 }
 
 class NativeViewportService::NativeViewportImpl
-    : public NativeViewportStub,
+    : public mojo::NativeViewport,

[DaveMoore, 2013/12/27 17:58:55]

I think we're going to find ourselves with these kinds of name collisions more
with this model, and it could get confusing. For the service FooService you have
Foo and FooClient as mojom generated names. Then you have to create a service
implementation, which needs an internal class that represents a connection to a
specific client, as well as an implementation of that client. So the pattern
I've been using is

Foo: thing that there is one of, that the ServiceManager uses to vend
connections.
FooServiceImpl: Inherits from FooServiceStub. Connection to a specific client.
Foo keeps a vector of the extant ones
FooClientImpl: The client implementation. inherits from FooClientStub. 

       public NativeViewportDelegate {
  public:
   NativeViewportImpl(NativeViewportService* service,
                      ScopedMessagePipeHandle client_handle)
       : service_(service),
         widget_(gfx::kNullAcceleratedWidget),
         waiting_for_event_ack_(false),
         pending_event_timestamp_(0),
-        client_(client_handle.Pass()) {
-    client_.SetPeer(this);
+        client_(client_handle.Pass(), this) {
   }
   virtual ~NativeViewportImpl() {}
 
   virtual void Open() MOJO_OVERRIDE {
     native_viewport_ =
         services::NativeViewport::Create(service_->context_, this);
     native_viewport_->Init();
     client_->OnCreated();
   }
 
@@ skipping 99 matching lines @@
   scoped_ptr<services::NativeViewport> native_viewport_;
   scoped_ptr<GLES2Impl> gles2_;
   bool waiting_for_event_ack_;
   int64 pending_event_timestamp_;
 
   RemotePtr<NativeViewportClient> client_;
 };
 
 NativeViewportService::NativeViewportService(
     ScopedMessagePipeHandle shell_handle)
-    : shell_(shell_handle.Pass()),
+    : shell_(shell_handle.Pass(), this),
       context_(NULL) {
-  shell_.SetPeer(this);
 }
 
 NativeViewportService::~NativeViewportService() {}
 
 void NativeViewportService::AcceptConnection(
     ScopedMessagePipeHandle client_handle) {
   // TODO(davemoore): We need a mechanism to determine when connectors
   // go away, so we can remove viewports correctly.
   viewports_.push_back(new NativeViewportImpl(this, client_handle.Pass()));
 }
@@ skipping 19 matching lines @@
   base::MessageLoopForUI loop;
   mojo::services::NativeViewportService app(
       mojo::MakeScopedHandle(mojo::MessagePipeHandle(shell_handle)).Pass());
   base::MessageLoop::current()->Run();
 
   mojo::BindingsSupport::Set(NULL);
   return MOJO_RESULT_OK;
 }
 
 #endif // !OS_ANDROID