Mandoline: Allow submitting CompositorFrames directly to mojo::Views

components/pdf_viewer/pdf_viewer.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 "base/bind.h"
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
 #include "components/view_manager/public/cpp/types.h"
 #include "components/view_manager/public/cpp/view.h"
 #include "components/view_manager/public/cpp/view_observer.h"
+#include "components/view_manager/public/cpp/view_surface.h"
 #include "components/view_manager/public/cpp/view_tree_connection.h"
 #include "components/view_manager/public/cpp/view_tree_delegate.h"
+#include "components/view_manager/public/interfaces/compositor_frame.mojom.h"
 #include "components/view_manager/public/interfaces/gpu.mojom.h"
 #include "components/view_manager/public/interfaces/surface_id.mojom.h"
-#include "components/view_manager/public/interfaces/surfaces.mojom.h"
 #include "gpu/GLES2/gl2chromium.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/application/public/cpp/application_delegate.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/application/public/cpp/application_runner.h"
 #include "mojo/application/public/cpp/connect.h"
 #include "mojo/application/public/cpp/content_handler_factory.h"
 #include "mojo/application/public/cpp/interface_factory_impl.h"
 #include "mojo/application/public/cpp/service_provider_impl.h"
 #include "mojo/application/public/interfaces/content_handler.mojom.h"
 #include "mojo/application/public/interfaces/shell.mojom.h"
 #include "mojo/common/data_pipe_utils.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
+#include "mojo/converters/surfaces/surfaces_type_converters.h"
 #include "mojo/converters/surfaces/surfaces_utils.h"
 #include "mojo/public/c/gles2/gles2.h"
 #include "mojo/public/c/system/main.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "third_party/pdfium/public/fpdf_ext.h"
 #include "third_party/pdfium/public/fpdfview.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/mojo/events/input_events.mojom.h"
 #include "ui/mojo/events/input_key_codes.mojom.h"
 #include "ui/mojo/geometry/geometry.mojom.h"
 #include "ui/mojo/geometry/geometry_util.h"
 #include "v8/include/v8.h"
 
 const uint32_t g_background_color = 0xFF888888;
 const uint32_t g_transparent_color = 0x00000000;
 
 namespace pdf_viewer {
 namespace {
 
 void LostContext(void*) {
   DCHECK(false);
 }
 
 // BitmapUploader is useful if you want to draw a bitmap or color in a View.
-class BitmapUploader : public mojo::ResourceReturner {
+class BitmapUploader : public mojo::SurfaceClient {
  public:
   explicit BitmapUploader(mojo::View* view)
       : view_(view),
         color_(g_transparent_color),
         width_(0),
         height_(0),
         format_(BGRA),
         next_resource_id_(1u),
         id_namespace_(0u),
         local_id_(0u),
         returner_binding_(this) {
   }
   ~BitmapUploader() override {
     MojoGLES2DestroyContext(gles2_context_);
   }
 
   void Init(mojo::Shell* shell) {
-    mojo::ServiceProviderPtr surfaces_service_provider;
-    mojo::URLRequestPtr request(mojo::URLRequest::New());
-    request->url = mojo::String::From("mojo:view_manager");
-    shell->ConnectToApplication(request.Pass(),
-                                mojo::GetProxy(&surfaces_service_provider),
-                                nullptr, nullptr);
-    ConnectToService(surfaces_service_provider.get(), &surface_);
-    surface_->GetIdNamespace(
-        base::Bind(&BitmapUploader::SetIdNamespace, base::Unretained(this)));
-    mojo::ResourceReturnerPtr returner_ptr;
-    returner_binding_.Bind(GetProxy(&returner_ptr));
-    surface_->SetResourceReturner(returner_ptr.Pass());
+    surface_ = view_->RequestSurface();
 
     mojo::ServiceProviderPtr gpu_service_provider;
     mojo::URLRequestPtr request2(mojo::URLRequest::New());
     request2->url = mojo::String::From("mojo:view_manager");
     shell->ConnectToApplication(request2.Pass(),
                                 mojo::GetProxy(&gpu_service_provider), nullptr,
                                 nullptr);
     ConnectToService(gpu_service_provider.get(), &gpu_service_);
 
     mojo::CommandBufferPtr gles2_client;
@@ skipping 26 matching lines @@
     width_ = width;
     height_ = height;
     bitmap_ = data.Pass();
     format_ = format;
     if (surface_)
       Upload();
   }
 
  private:
   void Upload() {
-    mojo::Size size;
-    size.width = view_->bounds().width;
-    size.height = view_->bounds().height;
-    if (!size.width || !size.height) {
-      view_->SetSurfaceId(mojo::SurfaceId::New());
-      return;
-    }
-
-    if (id_namespace_ == 0u)  // Can't generate a qualified ID yet.
-      return;
-
-    if (size != surface_size_) {
-      if (local_id_ != 0u) {
-        surface_->DestroySurface(local_id_);
-      }
-      local_id_++;
-      surface_->CreateSurface(local_id_);
-      surface_size_ = size;
-      auto qualified_id = mojo::SurfaceId::New();
-      qualified_id->id_namespace = id_namespace_;
-      qualified_id->local = local_id_;
-      view_->SetSurfaceId(qualified_id.Pass());
-    }
-
-    gfx::Rect bounds(size.width, size.height);
+    gfx::Rect bounds(view_->bounds().To<gfx::Rect>());
     mojo::PassPtr pass = mojo::CreateDefaultPass(1, bounds);
     mojo::CompositorFramePtr frame = mojo::CompositorFrame::New();
     frame->resources.resize(0u);
 
     pass->quads.resize(0u);
     pass->shared_quad_states.push_back(
-        mojo::CreateDefaultSQS(size.To<gfx::Size>()));
+        mojo::CreateDefaultSQS(bounds.size()));
 
     MojoGLES2MakeCurrent(gles2_context_);
     if (bitmap_.get()) {
       mojo::Size bitmap_size;
       bitmap_size.width = width_;
       bitmap_size.height = height_;
       GLuint texture_id = BindTextureForSize(bitmap_size);
       glTexSubImage2D(GL_TEXTURE_2D,
                       0,
                       0,
@@ skipping 23 matching lines @@
       mailbox_holder->texture_target = GL_TEXTURE_2D;
       mailbox_holder->sync_point = sync_point;
       resource->mailbox_holder = mailbox_holder.Pass();
       resource->is_repeated = false;
       resource->is_software = false;
 
       mojo::QuadPtr quad = mojo::Quad::New();
       quad->material = mojo::MATERIAL_TEXTURE_CONTENT;
 
       mojo::RectPtr rect = mojo::Rect::New();
-      if (width_ <= size.width && height_ <= size.height) {
+      if (width_ <= bounds.width() && height_ <= bounds.height()) {
         rect->width = width_;
         rect->height = height_;
       } else {
         // The source bitmap is larger than the viewport. Resize it while
         // maintaining the aspect ratio.
-        float width_ratio = static_cast<float>(width_) / size.width;
-        float height_ratio = static_cast<float>(height_) / size.height;
+        float width_ratio = static_cast<float>(width_) / bounds.width();
+        float height_ratio = static_cast<float>(height_) / bounds.height();
         if (width_ratio > height_ratio) {
-          rect->width = size.width;
+          rect->width = bounds.width();
           rect->height = height_ / width_ratio;
         } else {
-          rect->height = size.height;
+          rect->height = bounds.height();
           rect->width = width_ / height_ratio;
         }
       }
       quad->rect = rect.Clone();
       quad->opaque_rect = rect.Clone();
       quad->visible_rect = rect.Clone();
       quad->needs_blending = true;
       quad->shared_quad_state_index = 0u;
 
       mojo::TextureQuadStatePtr texture_state = mojo::TextureQuadState::New();
@@ skipping 28 matching lines @@
       color_state->color = mojo::Color::New();
       color_state->color->rgba = color_;
       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(local_id_, frame.Pass(), mojo::Closure());
+    // TODO(rjkroege, fsamuel): We should throttle frames.
+    surface_->SubmitCompositorFrame(frame.Pass());
   }
 
   uint32_t BindTextureForSize(const mojo::Size size) {
     // TODO(jamesr): Recycle textures.
     GLuint texture = 0u;
     glGenTextures(1, &texture);
     glBindTexture(GL_TEXTURE_2D, texture);
     glTexImage2D(GL_TEXTURE_2D,
                  0,
                  TextureFormat(),
@@ skipping 10 matching lines @@
   uint32_t TextureFormat() {
     return format_ == BGRA ? GL_BGRA_EXT : GL_RGBA;
   }
 
   void SetIdNamespace(uint32_t id_namespace) {
     id_namespace_ = id_namespace;
     if (color_ != g_transparent_color || bitmap_.get())
       Upload();
   }
 
-  // ResourceReturner implementation.
+  // SurfaceClient implementation.
   void ReturnResources(
       mojo::Array<mojo::ReturnedResourcePtr> resources) override {
     MojoGLES2MakeCurrent(gles2_context_);
     // TODO(jamesr): Recycle.
     for (size_t i = 0; i < resources.size(); ++i) {
       mojo::ReturnedResourcePtr resource = resources[i].Pass();
       DCHECK_EQ(1, resource->count);
       glWaitSyncPointCHROMIUM(resource->sync_point);
       uint32_t texture_id = resource_to_texture_id_map_[resource->id];
       DCHECK_NE(0u, texture_id);
       resource_to_texture_id_map_.erase(resource->id);
       glDeleteTextures(1, &texture_id);
     }
   }
 
   mojo::View* view_;
   mojo::GpuPtr gpu_service_;
+  scoped_ptr<mojo::ViewSurface> surface_;
   MojoGLES2Context gles2_context_;
 
   mojo::Size size_;
   uint32_t color_;
   int width_;
   int height_;
   Format format_;
   scoped_ptr<std::vector<unsigned char>> bitmap_;
-  mojo::SurfacePtr surface_;
-  mojo::Size surface_size_;
   uint32_t next_resource_id_;
   uint32_t id_namespace_;
   uint32_t local_id_;
   base::hash_map<uint32_t, uint32_t> resource_to_texture_id_map_;
-  mojo::Binding<mojo::ResourceReturner> returner_binding_;
+  mojo::Binding<mojo::SurfaceClient> returner_binding_;
 
   DISALLOW_COPY_AND_ASSIGN(BitmapUploader);
 };
 
 class EmbedderData {
  public:
   EmbedderData(mojo::Shell* shell, mojo::View* root) : bitmap_uploader_(root) {
     bitmap_uploader_.Init(shell);
     bitmap_uploader_.SetColor(g_background_color);
   }
@@ skipping 197 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(PDFViewer);
 };
 
 }  // namespace
 }  // namespace pdf_viewer
 
 MojoResult MojoMain(MojoHandle application_request) {
   mojo::ApplicationRunner runner(new pdf_viewer::PDFViewer());
   return runner.Run(application_request);
 }