Add a Display and ContextProvider concept to mojom, use to recreate

examples/sample_app/sample_app.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 <stdio.h>
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "examples/sample_app/gles2_client_impl.h"
@@ skipping 20 matching lines @@
     // TODO(darin): Fix shutdown so we don't need to leak this.
     mojo_ignore_result(gles2_client_.release());
   }
 
   void Initialize(mojo::ApplicationImpl* app) override {
     app->ConnectToService("mojo:native_viewport_service", &viewport_);
     viewport_.set_error_handler(this);
 
     SetEventDispatcher();
 
-    // TODO(jamesr): Should be mojo:gpu_service
-    app->ConnectToService("mojo:native_viewport_service", &gpu_service_);
-
     mojo::SizePtr size(mojo::Size::New());
     size->width = 800;
     size->height = 600;
-    viewport_->Create(size.Pass(),
-                      base::Bind(&SampleApp::OnCreatedNativeViewport,
-                                 base::Unretained(this)));
+    viewport_->Create(size.Clone(), base::Bind(&SampleApp::OnMetricsChanged,
+                                               base::Unretained(this)));
     viewport_->Show();
+    mojo::ContextProviderPtr onscreen_context_provider;
+    viewport_->GetContextProvider(GetProxy(&onscreen_context_provider));
+
+    gles2_client_.reset(new GLES2ClientImpl(onscreen_context_provider.Pass()));
+    gles2_client_->SetSize(*size);

[qsr, 2015/02/23 12:32:52]

I don't know if it matters that much, but this seems weird. We do not have
guarantee that we get a context with the requested size (and in fact, we mostly
don't on Android where the context size is always the screen size). Should we
wait for the OnMetriscChanged call before setting the size?

[jamesr, 2015/03/04 00:19:51]

The size isn't needed until it's time to draw, really, all gles2_client does it
store it so it can perform math at draw time. It won't actually draw until it
gets a context from the ContextProvider which is after the actual native widget
is created.  Deferring setting the size until OnMetricsChanged adds another
state that gles2_client has to worry about where it has a context but no size.

If we end up drawing a frame or few with the wrong size nothing really bad
happens.  Maybe it looks weird but this is just a pretty dumb demo.  Whenever
the real size comes up we'll start drawing cubes that look better.

   }
 
   void OnMetricsChanged(mojo::ViewportMetricsPtr metrics) {
     assert(metrics);
-    if (gles2_client_)
-      gles2_client_->SetSize(*metrics->size);
+    gles2_client_->SetSize(*metrics->size);
     viewport_->RequestMetrics(
         base::Bind(&SampleApp::OnMetricsChanged, base::Unretained(this)));
   }
 
   void OnEvent(mojo::EventPtr event,
                const mojo::Callback<void()>& callback) override {
     assert(event);
     if (event->location_data && event->location_data->in_view_location)
       gles2_client_->HandleInputEvent(*event);
     callback.Run();
   }
 
  private:
   void SetEventDispatcher() {
     mojo::NativeViewportEventDispatcherPtr ptr;
     dispatcher_binding_.Bind(GetProxy(&ptr));
     viewport_->SetEventDispatcher(ptr.Pass());
   }
 
-  void OnCreatedNativeViewport(uint64_t native_viewport_id,
-                               mojo::ViewportMetricsPtr metrics) {
-    mojo::ViewportParameterListenerPtr listener;
-    mojo::CommandBufferPtr command_buffer;
-    // TODO(jamesr): Output to a surface instead.
-    gpu_service_->CreateOnscreenGLES2Context(
-        native_viewport_id, metrics->size.Clone(), GetProxy(&command_buffer),
-        listener.Pass());
-    gles2_client_.reset(new GLES2ClientImpl(command_buffer.Pass()));
-    gles2_client_->SetSize(*metrics->size);
-    viewport_->RequestMetrics(
-        base::Bind(&SampleApp::OnMetricsChanged, base::Unretained(this)));
-  }
-
   // ErrorHandler implementation.
   void OnConnectionError() override { mojo::RunLoop::current()->Quit(); }
 
   scoped_ptr<GLES2ClientImpl> gles2_client_;
   mojo::NativeViewportPtr viewport_;
-  mojo::GpuPtr gpu_service_;
+  mojo::ContextProviderPtr onscreen_context_provider_;
   mojo::Binding<NativeViewportEventDispatcher> dispatcher_binding_;
 
   DISALLOW_COPY_AND_ASSIGN(SampleApp);
 };
 
 }  // namespace examples
 
 MojoResult MojoMain(MojoHandle shell_handle) {
   mojo::ApplicationRunner runner(new examples::SampleApp);
   return runner.Run(shell_handle);
 }