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/lib/view_manager_client_impl.h"
 #include "components/view_manager/public/cpp/types.h"
@@ skipping 54 matching lines @@
         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());
+    view_->RequestCompositorFrameReceiver(GetProxy(&cc_frame_receiver_));
 
     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;
     gpu_service_->CreateOffscreenGLES2Context(GetProxy(&gles2_client));
     gles2_context_ = MojoGLES2CreateContext(
         gles2_client.PassInterface().PassHandle().release().value(),
         &LostContext, NULL, mojo::Environment::GetDefaultAsyncWaiter());
     MojoGLES2MakeCurrent(gles2_context_);
   }
 
   // Sets the color which is RGBA.
   void SetColor(uint32_t color) {
     if (color_ == color)
       return;
     color_ = color;
-    if (surface_)
+    if (cc_frame_receiver_)
       Upload();
   }
 
   enum Format {
     RGBA,  // Pixel layout on Android.
     BGRA,  // Pixel layout everywhere else.
   };
 
   // Sets a bitmap.
   void SetBitmap(int width,
                  int height,
                  scoped_ptr<std::vector<unsigned char>> data,
                  Format format) {
     width_ = width;
     height_ = height;
     bitmap_ = data.Pass();
     format_ = format;
-    if (surface_)
+    if (cc_frame_receiver_)
       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();

[rjkroege, 2015/08/21 18:54:45]

you have tested this in high DIP mode?

[Fady Samuel, 2015/08/21 21:31:10]

This code worked in the past on android, and this patch makes no changes in
behavior. This is just avoiding storing the size in a mojo::Size since we don't
need to..

[rjkroege, 2015/08/21 22:58:00]

you are making a presumption that bounds and size are in the same units. Did you
confirm that they are. there use to be subtleties with this.

[Fady Samuel, 2015/08/21 23:15:26]

There is no unit conversion above.

+        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_->SubmitFrame(local_id_, frame.Pass(), mojo::Closure());
+    cc_frame_receiver_->SubmitCompositorFrame(frame.Pass(), mojo::Closure());

[rjkroege, 2015/08/19 23:45:44]

replacing this mojo::Closure() here with a real callback would probably permit
improving perf.

[Fady Samuel, 2015/08/20 16:22:44]

Added TODO.

   }
 
   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 28 matching lines @@
       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_;
+  mojo::CompositorFrameReceiverPtr cc_frame_receiver_;
   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_;
 
   DISALLOW_COPY_AND_ASSIGN(BitmapUploader);
 };
 
 class EmbedderData {
@@ skipping 196 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);
 }