[Aura] Added Support for rendering software compositor frames as cc::TextureLayers.

content/browser/renderer_host/render_widget_host_view_aura.cc

 // Copyright (c) 2012 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/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
+#include "cc/resources/texture_mailbox.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/accessibility/browser_accessibility_state_impl.h"
 #include "content/browser/renderer_host/backing_store_aura.h"
 #include "content/browser/renderer_host/dip_util.h"
 #include "content/browser/renderer_host/overscroll_controller.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/touch_smooth_scroll_gesture_aura.h"
 #include "content/browser/renderer_host/ui_events_helper.h"
 #include "content/browser/renderer_host/web_input_event_aura.h"
@@ skipping 311 matching lines @@
   } else if (skip_frame) {
     ack.mailbox_name = received_mailbox;
     ack.sync_point = 0;
   }
 
   ack.sync_point = sync_point;
   RenderWidgetHostImpl::AcknowledgeBufferPresent(
       route_id, gpu_host_id, ack);
 }
 
+void ReleaseMailbox(base::SharedMemory* shared_memory,
+                    base::Callback<void()> callback,
+                    unsigned sync_point, bool lost_resource) {
+  delete shared_memory;
+  callback.Run();
+}
+
 }  // namespace
 
 // We need to watch for mouse events outside a Web Popup or its parent
 // and dismiss the popup for certain events.
 class RenderWidgetHostViewAura::EventFilterForPopupExit :
     public ui::EventHandler {
  public:
   explicit EventFilterForPopupExit(RenderWidgetHostViewAura* rwhva)
       : rwhva_(rwhva) {
     DCHECK(rwhva_);
@@ skipping 577 matching lines @@
 
 void RenderWidgetHostViewAura::Blur() {
   window_->Blur();
 }
 
 bool RenderWidgetHostViewAura::HasFocus() const {
   return window_->HasFocus();
 }
 
 bool RenderWidgetHostViewAura::IsSurfaceAvailableForCopy() const {
-  return current_surface_ || current_dib_ || !!host_->GetBackingStore(false);
+  return current_surface_ ||
+      current_software_frame_.IsValid() ||
+      !!host_->GetBackingStore(false);
 }
 
 void RenderWidgetHostViewAura::Show() {
   window_->Show();
 }
 
 void RenderWidgetHostViewAura::Hide() {
   window_->Hide();
 }
 
@@ skipping 323 matching lines @@
   }
 
   scoped_callback_runner.Release();
   yuv_readback_pipeline_->ReadbackYUV(
       current_surface_->PrepareTexture(),
       target,
       callback);
 }
 
 bool RenderWidgetHostViewAura::CanCopyToVideoFrame() const {
+  // TODO(skaslev): Implement this path for s/w compositing.
   return current_surface_ != NULL && host_->is_accelerated_compositing_active();
 }
 
 bool RenderWidgetHostViewAura::CanSubscribeFrame() const {
   return true;
 }
 
 void RenderWidgetHostViewAura::BeginFrameSubscription(
     scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) {
   frame_subscriber_ = subscriber.Pass();
@@ skipping 42 matching lines @@
 
 void RenderWidgetHostViewAura::UpdateExternalTexture() {
   // Delay processing accelerated compositing state change till here where we
   // act upon the state change. (Clear the external texture if switching to
   // software mode or set the external texture if going to accelerated mode).
   if (accelerated_compositing_state_changed_)
     accelerated_compositing_state_changed_ = false;
 
   bool is_compositing_active = host_->is_accelerated_compositing_active();
   if (is_compositing_active && current_surface_) {
-    window_->SetExternalTexture(current_surface_.get());
+    window_->layer()->SetExternalTexture(current_surface_.get());
     current_frame_size_ = ConvertSizeToDIP(
         current_surface_->device_scale_factor(), current_surface_->size());
     CheckResizeLock();
-  } else if (is_compositing_active && current_dib_) {
-    window_->SetExternalTexture(NULL);
-    current_frame_size_ = ConvertSizeToDIP(last_swapped_surface_scale_factor_,
-                                           last_swapped_surface_size_);
+  } else if (is_compositing_active &&
+             current_software_frame_.IsSharedMemory()) {
+    window_->layer()->SetTextureMailbox(current_software_frame_,
+                                        last_swapped_surface_scale_factor_);
+    current_frame_size_ = ConvertSizeToDIP(
+        last_swapped_surface_scale_factor_,
+        current_software_frame_.shared_memory_size());
     CheckResizeLock();
   } else {
-    window_->SetExternalTexture(NULL);
+    window_->layer()->SetExternalTexture(NULL);
     resize_lock_.reset();
     host_->WasResized();
   }
 }
 
 bool RenderWidgetHostViewAura::SwapBuffersPrepare(
     const gfx::Rect& surface_rect,
     float surface_scale_factor,
     const gfx::Rect& damage_rect,
     const std::string& mailbox_name,
@@ skipping 137 matching lines @@
 void RenderWidgetHostViewAura::SendDelegatedFrameAck() {
   cc::CompositorFrameAck ack;
   window_->layer()->TakeUnusedResourcesForChildCompositor(&ack.resources);
   RenderWidgetHostImpl::SendSwapCompositorFrameAck(
       host_->GetRoutingID(), host_->GetProcess()->GetID(), ack);
 }
 
 void RenderWidgetHostViewAura::SwapSoftwareFrame(
     scoped_ptr<cc::SoftwareFrameData> frame_data,
     float frame_device_scale_factor) {
+  base::SharedMemoryHandle handle = frame_data->handle;
+#ifdef OS_WIN
+  BOOL success = ::DuplicateHandle(
+      host_->GetProcess()->GetHandle(), frame_data->handle,
+      ::GetCurrentProcess(), &handle,
+      0, TRUE, DUPLICATE_SAME_ACCESS);
+  if (!success) {
+    host_->GetProcess()->ReceivedBadMessage();
+    return;
+  }
+#endif
+  scoped_ptr<base::SharedMemory> shared_memory(
+      new base::SharedMemory(handle, false));
+
   const gfx::Size& frame_size = frame_data->size;
   const gfx::Rect& damage_rect = frame_data->damage_rect;
-  const TransportDIB::Id& dib_id = frame_data->dib_id;
-  scoped_ptr<TransportDIB> dib(host_->GetProcess()->MapTransportDIB(dib_id));
-
-  // Validate the received DIB.
-  size_t expected_size = 4 * frame_size.GetArea();
-  if (!dib || dib->size() < expected_size) {
-    host_->GetProcess()->ReceivedBadMessage();
+  gfx::Size frame_size_in_dip =
+      ConvertSizeToDIP(frame_device_scale_factor, frame_size);
+  if (ShouldSkipFrame(frame_size_in_dip)) {
+    SendSoftwareFrameAck(frame_data->id);
     return;
   }
 
   if (last_swapped_surface_size_ != frame_size) {
     DLOG_IF(ERROR, damage_rect != gfx::Rect(frame_size))
-      << "Expected full damage rect";
+        << "Expected full damage rect";
   }
-
-  TransportDIB::Id last_dib_id = current_dib_id_;
-  current_dib_.reset(dib.release());
-  current_dib_id_ = dib_id;
   last_swapped_surface_size_ = frame_size;
   last_swapped_surface_scale_factor_ = frame_device_scale_factor;
 
-  ui::Compositor* compositor = GetCompositor();
-  if (!compositor) {
-    SendSoftwareFrameAck(last_dib_id);
-    return;
-  }
+  cc::TextureMailbox::ReleaseCallback callback =
+      base::Bind(ReleaseMailbox, shared_memory.release(),

[piman, 2013/06/05 00:30:55]

nit: you can use Passed(new_buffer), and make ReleaseMailbox take a scoped_ptr
and this makes it safer if ever the callback is destroyed without being called
because the message loop is gone or something.

[slavi, 2013/06/06 23:02:47]

Done.

+                 base::Bind(&RenderWidgetHostViewAura::SendSoftwareFrameAck,
+                            AsWeakPtr(), frame_data->id));
+  current_software_frame_ = cc::TextureMailbox(handle, frame_size, callback);
+  DCHECK(current_software_frame_.IsSharedMemory());
+  current_frame_size_ = frame_size_in_dip;
 
-  gfx::Size frame_size_in_dip =
-      ConvertSizeToDIP(frame_device_scale_factor, frame_size);
-  if (ShouldSkipFrame(frame_size_in_dip)) {
-    can_lock_compositor_ = NO_PENDING_COMMIT;
-    SendSoftwareFrameAck(last_dib_id);
-  } else {
-    AddOnCommitCallbackAndDisableLocks(
-        base::Bind(&RenderWidgetHostViewAura::SendSoftwareFrameAck,
-                   AsWeakPtr(), last_dib_id));
-  }
-
-  current_frame_size_ = frame_size_in_dip;
+  released_front_lock_ = NULL;
   CheckResizeLock();
-  released_front_lock_ = NULL;
-  window_->SetExternalTexture(NULL);
+  window_->layer()->SetTextureMailbox(current_software_frame_,
+                                      frame_device_scale_factor);
   window_->SchedulePaintInRect(
       ConvertRectToDIP(frame_device_scale_factor, damage_rect));
-
   if (paint_observer_)
     paint_observer_->OnUpdateCompositorContent();
 }
 
-void RenderWidgetHostViewAura::SendSoftwareFrameAck(
-    const TransportDIB::Id& id) {
+void RenderWidgetHostViewAura::SendSoftwareFrameAck(int software_frame_id) {
   cc::CompositorFrameAck ack;
-  ack.last_dib_id = id;
+  ack.last_software_frame_id = software_frame_id;
   RenderWidgetHostImpl::SendSwapCompositorFrameAck(
       host_->GetRoutingID(), host_->GetProcess()->GetID(), ack);
 }
 
 void RenderWidgetHostViewAura::OnSwapCompositorFrame(
     scoped_ptr<cc::CompositorFrame> frame) {
   if (frame->delegated_frame_data) {
     SwapDelegatedFrame(frame->delegated_frame_data.Pass(),
                        frame->metadata.device_scale_factor);
     return;
@@ skipping 589 matching lines @@
   return popup_type_ == WebKit::WebPopupTypeNone;
 }
 
 void RenderWidgetHostViewAura::OnCaptureLost() {
   host_->LostCapture();
   if (touch_editing_client_)
     touch_editing_client_->EndTouchEditing();
 }
 
 void RenderWidgetHostViewAura::OnPaint(gfx::Canvas* canvas) {
-  bool is_compositing_active = host_->is_accelerated_compositing_active();
   bool has_backing_store = !!host_->GetBackingStore(false);
-  if (is_compositing_active && current_dib_) {
-    const gfx::Size window_size = window_->bounds().size();
-    const gfx::Size& frame_size = last_swapped_surface_size_;
-
-    SkBitmap bitmap;
-    bitmap.setConfig(SkBitmap::kARGB_8888_Config,
-                     frame_size.width(),
-                     frame_size.height());
-    bitmap.setPixels(current_dib_->memory());
-
-    SkCanvas* sk_canvas = canvas->sk_canvas();
-    sk_canvas->drawBitmap(bitmap, 0, 0);
-
-    if (frame_size != window_size) {
-      SkRegion region;
-      region.op(0, 0, window_size.width(), window_size.height(),
-                SkRegion::kUnion_Op);
-      region.op(0, 0, frame_size.width(), frame_size.height(),
-                SkRegion::kDifference_Op);
-      SkPaint paint;
-      paint.setColor(SK_ColorWHITE);
-      for (SkRegion::Iterator it(region); !it.done(); it.next())
-        sk_canvas->drawIRect(it.rect(), paint);
-    }
-
-    if (paint_observer_)
-      paint_observer_->OnPaintComplete();
-  } else if (!is_compositing_active && has_backing_store) {
+  if (has_backing_store) {
     paint_canvas_ = canvas;
     BackingStoreAura* backing_store = static_cast<BackingStoreAura*>(
         host_->GetBackingStore(true));
     paint_canvas_ = NULL;
     backing_store->SkiaShowRect(gfx::Point(), canvas);
 
     if (paint_observer_)
       paint_observer_->OnPaintComplete();
   } else if (aura::Env::GetInstance()->render_white_bg()) {
     canvas->DrawColor(SK_ColorWHITE);
@@ skipping 794 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content