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

examples/sample_app/gles2_client_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 "examples/sample_app/gles2_client_impl.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <math.h>
 #include <stdlib.h>
@@ skipping 10 matching lines @@
   return hypot(static_cast<float>(start.x - end.x),
                static_cast<float>(start.y - end.y));
 }
 
 float GetRandomColor() {
   return static_cast<float>(rand()) / static_cast<float>(RAND_MAX);
 }
 
 }
 
-GLES2ClientImpl::GLES2ClientImpl(mojo::CommandBufferPtr command_buffer)
-    : last_time_(mojo::GetTimeTicksNow()), waiting_to_draw_(false) {
-  context_ =
-      MojoGLES2CreateContext(command_buffer.PassMessagePipe().release().value(),
-                             &ContextLostThunk,
-                             this,
-                             mojo::Environment::GetDefaultAsyncWaiter());
-  MojoGLES2MakeCurrent(context_);
+GLES2ClientImpl::GLES2ClientImpl(mojo::ContextProviderPtr context_provider)
+    : last_time_(mojo::GetTimeTicksNow()),
+      waiting_to_draw_(false),
+      context_provider_(context_provider.Pass()),
+      context_(nullptr) {
+  context_provider_->Create(nullptr,
+                            [this](mojo::CommandBufferPtr command_buffer) {
+                              ContextCreated(command_buffer.Pass());
+                            });
 }
 
 GLES2ClientImpl::~GLES2ClientImpl() {
   MojoGLES2DestroyContext(context_);
 }
 
 void GLES2ClientImpl::SetSize(const mojo::Size& size) {
   size_ = size;
-  if (size_.width == 0 || size_.height == 0)
+  cube_.set_size(size_.width, size_.height);
+  if (size_.width == 0 || size_.height == 0 || !context_)
     return;
   static_cast<gpu::gles2::GLES2Interface*>(
       MojoGLES2GetGLES2Interface(context_))->ResizeCHROMIUM(size_.width,
                                                             size_.height,
                                                             1);
-  cube_.Init(size_.width, size_.height);
   WantToDraw();
 }
 
 void GLES2ClientImpl::HandleInputEvent(const mojo::Event& event) {
   switch (event.action) {
   case mojo::EVENT_TYPE_MOUSE_PRESSED:
   case mojo::EVENT_TYPE_TOUCH_PRESSED:
     if (event.flags & mojo::EVENT_FLAGS_RIGHT_MOUSE_BUTTON)
       break;
     capture_point_ = *event.location_data->in_view_location;
@@ skipping 29 matching lines @@
 
     capture_point_ = last_drag_point_ = mojo::Point();
     WantToDraw();
     break;
   }
   default:
     break;
   }
 }
 
+void GLES2ClientImpl::ContextCreated(mojo::CommandBufferPtr command_buffer) {
+  context_ = MojoGLES2CreateContext(
+      command_buffer.PassMessagePipe().release().value(), &ContextLostThunk,
+      this, mojo::Environment::GetDefaultAsyncWaiter());
+  MojoGLES2MakeCurrent(context_);
+  cube_.Init();
+  WantToDraw();
+}
+
 void GLES2ClientImpl::ContextLost() {
+  MojoGLES2DestroyContext(context_);
+  context_ = nullptr;
+  context_provider_->Create(nullptr,
+                            [this](mojo::CommandBufferPtr command_buffer) {
+                              ContextCreated(command_buffer.Pass());
+                            });
 }
 
 void GLES2ClientImpl::ContextLostThunk(void* closure) {
   static_cast<GLES2ClientImpl*>(closure)->ContextLost();
 }
 
-struct DrawRunnable {
-  explicit DrawRunnable(GLES2ClientImpl* impl) : impl(impl) {}
-  virtual ~DrawRunnable() {}
-
-  void Run() const { impl->Draw(); }
-
-  GLES2ClientImpl* impl;
-};
-
 void GLES2ClientImpl::WantToDraw() {
-  if (waiting_to_draw_)
+  if (waiting_to_draw_ || !context_)
     return;
   waiting_to_draw_ = true;
-  mojo::RunLoop::current()->PostDelayedTask(mojo::Closure(DrawRunnable(this)),
+  mojo::RunLoop::current()->PostDelayedTask([this]() { Draw(); },
                                             MojoTimeTicks(16667));

[qsr, 2015/02/20 11:25:47]

You can lose the context between this post task and the call to Draw, no? Should
you check for the context in Draw too?

Also, (but not sure if it is worth it for this app), maybe we still want to
update the cube data while we do not have a context, but we just do not want to
try to draw...

[jamesr, 2015/02/20 22:01:05]

fixed
no, it doesn't make sense to spend time updating the math on the cube when we
can't draw it.

 }
 
 void GLES2ClientImpl::Draw() {
   waiting_to_draw_ = false;
   MojoTimeTicks now = mojo::GetTimeTicksNow();
   MojoTimeTicks offset = now - last_time_;
   float delta = static_cast<float>(offset) / 1000000.;
   last_time_ = now;
   cube_.UpdateForTimeDelta(delta);
   cube_.Draw();
 
   MojoGLES2SwapBuffers();
   WantToDraw();
 }
 
 }  // namespace examples