mozart: Port the spinning cube example.

examples/ui/spinning_cube/spinning_cube_view.cc

Index: examples/ui/spinning_cube/spinning_cube_view.cc
diff --git a/examples/ui/spinning_cube/spinning_cube_view.cc b/examples/ui/spinning_cube/spinning_cube_view.cc
new file mode 100644
index 0000000000000000000000000000000000000000..59a352e70114851e916cf68438a2a7a917a0e2e0
--- /dev/null
+++ b/examples/ui/spinning_cube/spinning_cube_view.cc
@@ -0,0 +1,163 @@
+// 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 <GLES2/gl2.h>
+#include <GLES2/gl2extmojo.h>
+#include <MGL/mgl.h>
+
+#include "base/message_loop/message_loop.h"
+#include "examples/ui/spinning_cube/spinning_cube_view.h"
+
+namespace examples {
+
+SpinningCubeView::SpinningCubeView(
+    mojo::ApplicationImpl* app,
+    const mojo::ui::ViewProvider::CreateViewCallback& callback)
+    : callback_(callback),
+      binding_(this),
+      context_owner_(app->shell()),
+      texture_cache_(context_owner_.context(), &resource_returner_),
+      surface_id_namespace_(0),
+      draw_scheduled_(false),
+      weak_ptr_factory_(this) {
+  app->ConnectToService("mojo:surfaces_service", &surfaces_);
+  app->ConnectToService("mojo:view_manager_service", &view_manager_);
+
+  surfaces_->SetResourceReturner(resource_returner_.Pass());
+  surfaces_->GetIdNamespace(
+      base::Bind(&SpinningCubeView::OnSurfaceIdNamespaceAvailable,
+                 base::Unretained(this)));
+
+  InitCube();
+}
+
+SpinningCubeView::~SpinningCubeView() {}
+
+void SpinningCubeView::OnSurfaceIdNamespaceAvailable(uint32_t id_namespace) {
+  surface_id_namespace_ = id_namespace;
+  InitView();
+}
+
+void SpinningCubeView::InitView() {
+  mojo::ui::ViewPtr view;
+  binding_.Bind(mojo::GetProxy(&view));
+  view_manager_->RegisterView(view.Pass(), mojo::GetProxy(&view_host_),
+                              callback_);
+
+  view_host_->GetServiceProvider(mojo::GetProxy(&view_service_provider_));
+}
+
+void SpinningCubeView::OnLayout(mojo::ui::ViewLayoutParamsPtr layout_params,
+                                mojo::Array<uint32_t> children_needing_layout,
+                                const OnLayoutCallback& callback) {
+  // Create a new surface the first time or if the size has changed.
+  mojo::Size new_size;
+  new_size.width = layout_params->constraints->max_width;
+  new_size.height = layout_params->constraints->max_height;
+  if (!surface_id_ || !size_.Equals(new_size)) {
+    if (!surface_id_) {
+      surface_id_ = mojo::SurfaceId::New();
+      surface_id_->id_namespace = surface_id_namespace_;
+    } else {
+      surfaces_->DestroySurface(surface_id_->local);
+    }
+    surface_id_->local++;
+    size_ = new_size;
+    surfaces_->CreateSurface(surface_id_->local);
+  }
+
+  // Submit the new layout information.
+  mojo::ui::ViewLayoutInfoPtr info = mojo::ui::ViewLayoutInfo::New();

[jamesr, 2015/10/27 23:04:23]

i pretty much use 'auto' with these ::New() factories since the type name is
spelled out in full on the RHS, but that's personal preference

[jeffbrown, 2015/10/27 23:48:16]

Sure!  That makes sense.

+  info->size = size_.Clone();
+  info->surface_id = surface_id_->Clone();
+  callback.Run(info.Pass());
+
+  // Draw!
+  ScheduleDraw();
+}
+
+void SpinningCubeView::OnChildUnavailable(
+    uint32_t child_key,
+    const OnChildUnavailableCallback& callback) {
+  callback.Run();
+}
+
+void SpinningCubeView::InitCube() {
+  context_owner_.context()->MakeCurrent();
+  cube_.Init();
+  last_draw_ = mojo::GetTimeTicksNow();
+}
+
+void SpinningCubeView::DrawCube() {
+  draw_scheduled_ = false;
+
+  context_owner_.context()->MakeCurrent();

[jamesr, 2015/10/27 23:04:23]

unless the context has to be current for the GetTexture() call i'd move this
below the early return to avoid churning the context in the failure case (it
obviously doesn't really matter in this example but people will copy-paste)

[jeffbrown, 2015/10/27 23:48:16]

It's needed by GetTexture although arguably that's a bug.  I'll go fix that.

+
+  scoped_ptr<mojo::TextureCache::TextureInfo> texture_info =
+      texture_cache_.GetTexture(size_);
+  if (!texture_info) {
+    LOG(ERROR) << "Could not allocate texture of size " << size_.width << "x"
+               << size_.height;
+    return;
+  }
+
+  scoped_ptr<mojo::GLTexture> texture = texture_info->TakeTexture();
+
+  GLuint fbo = 0u;
+  glGenFramebuffers(1, &fbo);
+  glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+  GLuint depth_buffer = 0u;
+  glGenRenderbuffers(1, &depth_buffer);
+  glBindRenderbuffer(GL_RENDERBUFFER, depth_buffer);
+  glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, size_.width,
+                        size_.height);
+  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+                         texture->texture_id(), 0);
+  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                            GL_RENDERBUFFER, depth_buffer);
+  DCHECK_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
+            glCheckFramebufferStatus(GL_FRAMEBUFFER));
+  glClearColor(1, 0, 0, 0.5);
+
+  cube_.set_size(size_.width, size_.height);
+
+  MojoTimeTicks now = mojo::GetTimeTicksNow();
+  MojoTimeTicks offset = now - last_draw_;
+  cube_.UpdateForTimeDelta(offset * 0.000001f);
+  last_draw_ = now;
+
+  cube_.Draw();
+
+  glDeleteFramebuffers(1, &fbo);
+  glDeleteRenderbuffers(1, &depth_buffer);
+
+  mojo::FramePtr frame = mojo::TextureUploader::GetUploadFrame(
+      context_owner_.context(), texture_info->resource_id(), texture);
+  surfaces_->SubmitFrame(surface_id_->local, frame.Pass(),
+                         base::Bind(&SpinningCubeView::OnSurfaceSubmitted,
+                                    base::Unretained(this)));
+
+  texture_cache_.NotifyPendingResourceReturn(texture_info->resource_id(),
+                                             texture.Pass());
+}
+
+void SpinningCubeView::OnSurfaceSubmitted() {
+  ScheduleDraw();
+}
+
+void SpinningCubeView::ScheduleDraw() {
+  if (!draw_scheduled_) {
+    draw_scheduled_ = true;
+
+    // TODO(jeffbrown): For now, we need to throttle this down because
+    // drawing as fast as we can appears to cause starvation of the
+    // Mojo message loop and makes X11 unhappy.
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&SpinningCubeView::DrawCube, weak_ptr_factory_.GetWeakPtr()),
+        base::TimeDelta::FromMilliseconds(30));
+  }
+}
+
+}  // namespace examples