mustash: enable GPU Compositing in renderer

content/renderer/render_widget_mus_connection.cc

 // Copyright 2015 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 "content/renderer/render_widget_mus_connection.h"
 
+#include <map>
+
+#include "components/mus/public/cpp/context_provider.h"
 #include "components/mus/public/interfaces/compositor_frame.mojom.h"
+#include "components/mus/public/interfaces/gpu.mojom.h"
 #include "components/mus/public/interfaces/window_tree.mojom.h"
 #include "content/public/common/mojo_shell_connection.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/surfaces/surfaces_utils.h"
 
 namespace content {
 
+namespace {
+
+std::map<int, RenderWidgetMusConnection*>* g_connections = nullptr;
+
+}
+
 RenderWidgetMusConnection::RenderWidgetMusConnection(
     int routing_id,
     mojo::InterfaceRequest<mus::mojom::WindowTreeClient> request)
     : routing_id_(routing_id), root_(nullptr) {
+  fprintf(stderr, "EEE %s\n", __func__);
   // TODO(fsamuel): We should probably introduce a
   // RenderWidgetMusConnection::FromRoutingID that's usable from RenderWidget.
   // TODO(fsamuel): We probably want to pause processing of incoming
   // messages until we have an associated RenderWidget.
   mus::WindowTreeConnection::Create(
       this, request.Pass(),
       mus::WindowTreeConnection::CreateType::DONT_WAIT_FOR_EMBED);
+  if (!g_connections)
+    g_connections = new std::map<int, RenderWidgetMusConnection*>();
+
+  CHECK(g_connections->count(routing_id) == 0);
+  g_connections->insert(std::make_pair(routing_id, this));
 }
 
-RenderWidgetMusConnection::~RenderWidgetMusConnection() {}
+RenderWidgetMusConnection::~RenderWidgetMusConnection() {
+  fprintf(stderr, "EEE %s\n", __func__);
+  CHECK(g_connections->erase(routing_id_) == 1);
+}
+
+scoped_ptr<cc::OutputSurface> RenderWidgetMusConnection::CreateOutputSurface() {
+  fprintf(stderr, "EEE %s\n", __func__);
+  mus::mojom::GpuPtr gpu_service;
+  MojoShellConnection::Get()->GetApplication()->ConnectToService(
+      "mojo:mus", &gpu_service);
+  mus::mojom::CommandBufferPtr cb;
+  gpu_service->CreateOffscreenGLES2Context(GetProxy(&cb));
+  scoped_refptr<cc::ContextProvider> context_provider(
+      new mus::ContextProvider(cb.PassInterface().PassHandle()));
+  return make_scoped_ptr(new mus::OutputSurface(
+        context_provider,
+        root_->RequestSurface(mus::mojom::SURFACE_TYPE_DEFAULT)));
+}
+
+RenderWidgetMusConnection* RenderWidgetMusConnection::Get(int routing_id) {
+  fprintf(stderr, "EEE %s\n", __func__);
+  if (!g_connections)
+    return nullptr;
+
+  auto it = g_connections->find(routing_id);
+  if (it == g_connections->end())
+    return nullptr;
+
+  return it->second;
+
+}
 
 void RenderWidgetMusConnection::SubmitCompositorFrame() {
+#if 0
   const gfx::Rect bounds(root_->bounds());
   mus::mojom::PassPtr pass = mojo::CreateDefaultPass(1, bounds);
   mus::mojom::CompositorFramePtr frame = mus::mojom::CompositorFrame::New();
 
   mus::mojom::CompositorFrameMetadataPtr meta =
       mus::mojom::CompositorFrameMetadata::New();
   meta->device_scale_factor = 1.0f;
   frame->metadata = meta.Pass();
 
   frame->resources.resize(0u);
@@ skipping 12 matching lines @@
   mus::mojom::SolidColorQuadStatePtr color_state =
       mus::mojom::SolidColorQuadState::New();
   color_state->color = mus::mojom::Color::New();
   color_state->color->rgba = 0xff00ff00;
   color_state->force_anti_aliasing_off = false;
 
   quad->solid_color_quad_state = color_state.Pass();
   pass->quads.push_back(quad.Pass());
   frame->passes.push_back(pass.Pass());
   surface_->SubmitCompositorFrame(frame.Pass(), mojo::Closure());
+#endif
 }
 
 void RenderWidgetMusConnection::OnConnectionLost(
     mus::WindowTreeConnection* connection) {
   delete this;
 }
 
 void RenderWidgetMusConnection::OnEmbed(mus::Window* root) {
   root_ = root;
   root_->AddObserver(this);
   surface_ = root_->RequestSurface(mus::mojom::SURFACE_TYPE_DEFAULT);
   surface_->BindToThread();
   SubmitCompositorFrame();
 }
 
 void RenderWidgetMusConnection::OnUnembed() {}
 
 void RenderWidgetMusConnection::OnWindowBoundsChanged(
     mus::Window* window,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
   SubmitCompositorFrame();
 }
 
 }  // namespace content