content: Move Surfaces related code out of RWHVA.

content/browser/renderer_host/render_widget_host_view_android.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_android.h"
 
 #include <android/bitmap.h>
 
 #include <utility>
 
 #include "base/android/build_info.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/surface_layer.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/copy_output_request.h"
@@ skipping 39 matching lines @@
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/config/gpu_driver_bug_workaround_type.h"
 #include "ipc/ipc_message_macros.h"
 #include "ipc/ipc_message_start.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkCanvas.h"
-#include "ui/android/context_provider_factory.h"
+#include "ui/android/delegated_frame_host_android.h"
 #include "ui/android/window_android.h"
 #include "ui/android/window_android_compositor.h"
 #include "ui/base/layout.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/events/blink/blink_event_util.h"
 #include "ui/events/gesture_detection/gesture_provider_config_helper.h"
 #include "ui/events/gesture_detection/motion_event.h"
 #include "ui/gfx/android/device_display_info.h"
 #include "ui/gfx/android/java_bitmap.h"
 #include "ui/gfx/android/view_configuration.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/touch_selection/touch_selection_controller.h"
 
 namespace content {
 
 namespace {
 
-void SatisfyCallback(cc::SurfaceManager* manager,
-                     const cc::SurfaceSequence& sequence) {
-  std::vector<uint32_t> sequences;
-  sequences.push_back(sequence.sequence);
-  manager->DidSatisfySequences(sequence.client_id, &sequences);
-}
-
-void RequireCallback(cc::SurfaceManager* manager,
-                     const cc::SurfaceId& id,
-                     const cc::SurfaceSequence& sequence) {
-  cc::Surface* surface = manager->GetSurfaceForId(id);
-  if (!surface) {
-    LOG(ERROR) << "Attempting to require callback on nonexistent surface";
-    return;
-  }
-  surface->AddDestructionDependency(sequence);
-}
-
 const int kUndefinedOutputSurfaceId = -1;
 
 static const char kAsyncReadBackString[] = "Compositing.CopyFromSurfaceTime";
 
 class GLHelperHolder {
  public:
   static GLHelperHolder* Create();
 
   display_compositor::GLHelper* gl_helper() { return gl_helper_.get(); }
   bool IsLost() {
@@ skipping 153 matching lines @@
 gfx::RectF GetSelectionRect(const ui::TouchSelectionController& controller) {
   gfx::RectF rect = controller.GetRectBetweenBounds();
   if (rect.IsEmpty())
     return rect;
 
   rect.Union(controller.GetStartHandleRect());
   rect.Union(controller.GetEndHandleRect());
   return rect;
 }
 
-scoped_refptr<cc::SurfaceLayer> CreateSurfaceLayer(
-    const cc::SurfaceId& surface_id,
-    const gfx::Size& size) {
-  DCHECK(!surface_id.is_null());
-  cc::SurfaceManager* manager =
-      ui::ContextProviderFactory::GetInstance()->GetSurfaceManager();
-  DCHECK(manager);
-  // manager must outlive compositors using it.
-  scoped_refptr<cc::SurfaceLayer> surface_layer = cc::SurfaceLayer::Create(
-      base::Bind(&SatisfyCallback, base::Unretained(manager)),
-      base::Bind(&RequireCallback, base::Unretained(manager)));
-  surface_layer->SetSurfaceId(surface_id, 1.f, size);
-  surface_layer->SetBounds(size);
-  surface_layer->SetIsDrawable(true);
-  surface_layer->SetContentsOpaque(true);
-
-  return surface_layer;
-}
-
 }  // anonymous namespace
 
 RenderWidgetHostViewAndroid::LastFrameInfo::LastFrameInfo(
     uint32_t output_id,
     cc::CompositorFrame output_frame)
     : output_surface_id(output_id), frame(std::move(output_frame)) {}
 
 RenderWidgetHostViewAndroid::LastFrameInfo::~LastFrameInfo() {}
 
 void RenderWidgetHostViewAndroid::OnContextLost() {
@@ skipping 21 matching lines @@
       last_output_surface_id_(kUndefinedOutputSurfaceId),
       gesture_provider_(ui::GetGestureProviderConfig(
                             ui::GestureProviderConfigType::CURRENT_PLATFORM),
                         this),
       stylus_text_selector_(this),
       using_browser_compositor_(CompositorImpl::IsInitialized()),
       frame_evictor_(new DelegatedFrameEvictor(this)),
       locks_on_frame_count_(0),
       observing_root_window_(false),
       weak_ptr_factory_(this) {
+  // Set the layer which will hold the content layer for this view. The content
+  // layer is managed by the DelegatedFrameHost.
+  view_.SetLayer(cc::Layer::Create());
   if (using_browser_compositor_) {
-    id_allocator_.reset(new cc::SurfaceIdAllocator(
-        ui::ContextProviderFactory::GetInstance()->AllocateSurfaceClientId()));
-    ui::ContextProviderFactory::GetInstance()
-        ->GetSurfaceManager()
-        ->RegisterSurfaceClientId(id_allocator_->client_id());
+    delegated_frame_host_.reset(new ui::DelegatedFrameHostAndroid(
+        &view_, cached_background_color_,
+        base::Bind(&RenderWidgetHostViewAndroid::ReturnResources,
+                   weak_ptr_factory_.GetWeakPtr())));
   }
 
   host_->SetView(this);
   SetContentViewCore(content_view_core);
 }
 
 RenderWidgetHostViewAndroid::~RenderWidgetHostViewAndroid() {
   if (content_view_core_)
     content_view_core_->RemoveObserver(this);
   SetContentViewCore(NULL);
   DCHECK(ack_callbacks_.empty());
-  DCHECK(!surface_factory_);
-  DCHECK(surface_id_.is_null());
+  DCHECK(!delegated_frame_host_);
 }
 
 void RenderWidgetHostViewAndroid::Blur() {
   host_->Blur();
   if (overscroll_controller_)
     overscroll_controller_->Disable();
 }
 
 bool RenderWidgetHostViewAndroid::OnMessageReceived(
     const IPC::Message& message) {
@@ skipping 33 matching lines @@
     RenderWidgetHostView* reference_host_view) {
   NOTIMPLEMENTED();
 }
 
 RenderWidgetHost*
 RenderWidgetHostViewAndroid::GetRenderWidgetHost() const {
   return host_;
 }
 
 void RenderWidgetHostViewAndroid::WasResized() {
+  if (delegated_frame_host_)
+    delegated_frame_host_->UpdateContainerSizeinDIP(GetVisibleViewportSize());
   host_->WasResized();
 }
 
 void RenderWidgetHostViewAndroid::SetSize(const gfx::Size& size) {
   // Ignore the given size as only the Java code has the power to
   // resize the view on Android.
   default_size_ = size;
 }
 
 void RenderWidgetHostViewAndroid::SetBounds(const gfx::Rect& rect) {
   SetSize(rect.size());
 }
 
 void RenderWidgetHostViewAndroid::GetScaledContentBitmap(
     float scale,
     SkColorType preferred_color_type,
     gfx::Rect src_subrect,
     const ReadbackRequestCallback& result_callback) {
   if (!host_ || host_->is_hidden() || !IsSurfaceAvailableForCopy()) {
     result_callback.Run(SkBitmap(), READBACK_SURFACE_UNAVAILABLE);
     return;
   }
-  gfx::Size bounds = view_.GetLayer()->bounds();
+  gfx::Size bounds = current_surface_size_;
   if (src_subrect.IsEmpty())
     src_subrect = gfx::Rect(bounds);
   DCHECK_LE(src_subrect.width() + src_subrect.x(), bounds.width());
   DCHECK_LE(src_subrect.height() + src_subrect.y(), bounds.height());
   const display::Display& display =
       display::Screen::GetScreen()->GetPrimaryDisplay();
   float device_scale_factor = display.device_scale_factor();
   DCHECK_GT(device_scale_factor, 0);
   gfx::Size dst_size(
       gfx::ScaleToCeiledSize(src_subrect.size(), scale / device_scale_factor));
   src_subrect = gfx::ConvertRectToDIP(device_scale_factor, src_subrect);
 
   CopyFromCompositingSurface(src_subrect, dst_size, result_callback,
                              preferred_color_type);
 }
 
 bool RenderWidgetHostViewAndroid::HasValidFrame() const {
   if (!content_view_core_)
     return false;
-  if (!view_.GetLayer())
-    return false;
 
-  if (texture_size_in_layer_.IsEmpty())
+  if (current_surface_size_.IsEmpty())
     return false;
   // This tell us whether a valid frame has arrived or not.
   if (!frame_evictor_->HasFrame())
     return false;
 
+  DCHECK(!delegated_frame_host_ ||
+         delegated_frame_host_->HasDelegatedContent());
   return true;
 }
 
 gfx::Vector2dF RenderWidgetHostViewAndroid::GetLastScrollOffset() const {
   return last_scroll_offset_;
 }
 
 gfx::NativeView RenderWidgetHostViewAndroid::GetNativeView() const {
   return &view_;
 }
@@ skipping 17 matching lines @@
 }
 
 bool RenderWidgetHostViewAndroid::HasFocus() const {
   if (!content_view_core_)
     return false;  // ContentViewCore not created yet.
 
   return content_view_core_->HasFocus();
 }
 
 bool RenderWidgetHostViewAndroid::IsSurfaceAvailableForCopy() const {
-  return !using_browser_compositor_ ||
-         (HasValidFrame() && surface_factory_.get());
+  return !using_browser_compositor_ || HasValidFrame();
 }
 
 void RenderWidgetHostViewAndroid::Show() {
   if (is_showing_)
     return;
 
   is_showing_ = true;
   ShowInternal();
 }
 
@@ skipping 30 matching lines @@
   locks_on_frame_count_--;
   frame_evictor_->UnlockFrame();
 
   if (locks_on_frame_count_ == 0) {
     if (last_frame_info_) {
       InternalSwapCompositorFrame(last_frame_info_->output_surface_id,
                                   std::move(last_frame_info_->frame));
       last_frame_info_.reset();
     }
 
-    if (!is_showing_ && view_.GetLayer())
-      view_.GetLayer()->SetHideLayerAndSubtree(true);
+    view_.GetLayer()->SetHideLayerAndSubtree(!is_showing_);
   }
 }
 
 void RenderWidgetHostViewAndroid::OnShowUnhandledTapUIIfNeeded(int x_dip,
                                                                int y_dip) {
   if (!content_view_core_)
     return;
   // Validate the coordinates are within the viewport.
   gfx::Size viewport_size = content_view_core_->GetViewportSizeDip();
   if (x_dip < 0 || x_dip > viewport_size.width() ||
@@ skipping 82 matching lines @@
       params.value, params.selection_start, params.selection_end,
       params.composition_start, params.composition_end,
       params.show_ime_if_needed, params.is_non_ime_change);
 }
 
 void RenderWidgetHostViewAndroid::UpdateBackgroundColor(SkColor color) {
   if (cached_background_color_ == color)
     return;
 
   cached_background_color_ = color;
+  delegated_frame_host_->UpdateBackgroundColor(color);
   if (content_view_core_)
     content_view_core_->OnBackgroundColorChanged(color);
 }
 
 void RenderWidgetHostViewAndroid::OnSetNeedsBeginFrames(bool enabled) {
   TRACE_EVENT1("cc", "RenderWidgetHostViewAndroid::OnSetNeedsBeginFrames",
                "enabled", enabled);
   if (enabled)
     RequestVSyncUpdate(PERSISTENT_BEGIN_FRAME);
   else
@@ skipping 112 matching lines @@
   ime_adapter_android_.FocusedNodeChanged(is_editable_node);
 }
 
 void RenderWidgetHostViewAndroid::RenderProcessGone(
     base::TerminationStatus status, int error_code) {
   Destroy();
 }
 
 void RenderWidgetHostViewAndroid::Destroy() {
   host_->ViewDestroyed();
-  RemoveLayers();
   SetContentViewCore(NULL);
-
-  if (!surface_id_.is_null()) {
-    DCHECK(surface_factory_.get());
-    surface_factory_->Destroy(surface_id_);
-    surface_id_ = cc::SurfaceId();
-  }
-  surface_factory_.reset();
-  if (id_allocator_) {
-    ui::ContextProviderFactory::GetInstance()
-        ->GetSurfaceManager()
-        ->InvalidateSurfaceClientId(id_allocator_->client_id());
-  }
+  delegated_frame_host_.reset();
 
   // The RenderWidgetHost's destruction led here, so don't call it.
   host_ = NULL;
 
   delete this;
 }
 
 void RenderWidgetHostViewAndroid::SetTooltipText(
     const base::string16& tooltip_text) {
   // Tooltips don't makes sense on Android.
@@ skipping 65 matching lines @@
     SynchronousCopyContents(src_subrect_in_pixel, dst_size_in_pixel, callback,
                             preferred_color_type);
     UMA_HISTOGRAM_TIMES("Compositing.CopyFromSurfaceTimeSynchronous",
                         base::TimeTicks::Now() - start_time);
     return;
   }
 
   ui::WindowAndroidCompositor* compositor =
       content_view_core_->GetWindowAndroid()->GetCompositor();
   DCHECK(compositor);
-  DCHECK(!surface_id_.is_null());
-  scoped_refptr<cc::Layer> layer =
-      CreateSurfaceLayer(surface_id_, texture_size_in_layer_);
-  layer->SetHideLayerAndSubtree(true);
-  compositor->AttachLayerForReadback(layer);
-
-  std::unique_ptr<cc::CopyOutputRequest> request =
-      cc::CopyOutputRequest::CreateRequest(
-          base::Bind(&PrepareTextureCopyOutputResult,
-                     weak_ptr_factory_.GetWeakPtr(), layer, dst_size_in_pixel,
-                     preferred_color_type, start_time, callback));
-
-  if (!src_subrect_in_pixel.IsEmpty())
-    request->set_area(src_subrect_in_pixel);
-  surface_factory_->RequestCopyOfSurface(surface_id_, std::move(request));
+  delegated_frame_host_->RequestCopyOfSurface(
+      compositor, src_subrect_in_pixel,
+      base::Bind(&PrepareTextureCopyOutputResult, dst_size_in_pixel,
+                 preferred_color_type, start_time, callback));
 }
 
 void RenderWidgetHostViewAndroid::CopyFromCompositingSurfaceToVideoFrame(
     const gfx::Rect& src_subrect,
     const scoped_refptr<media::VideoFrame>& target,
     const base::Callback<void(const gfx::Rect&, bool)>& callback) {
   NOTIMPLEMENTED();
   callback.Run(gfx::Rect(), false);
 }
 
@@ skipping 30 matching lines @@
     const cc::ReturnedResourceArray& resources) {
   if (resources.empty())
     return;
   std::copy(resources.begin(), resources.end(),
             std::back_inserter(surface_returned_resources_));
   if (ack_callbacks_.empty())
     SendReclaimCompositorResources(last_output_surface_id_,
                                    false /* is_swap_ack */);
 }
 
-void RenderWidgetHostViewAndroid::SetBeginFrameSource(
-    cc::BeginFrameSource* begin_frame_source) {
-  // TODO(tansell): Hook this up.
-}
-
-void RenderWidgetHostViewAndroid::DestroyDelegatedContent() {
-  RemoveLayers();
-  if (!surface_id_.is_null()) {
-    DCHECK(surface_factory_.get());
-    cc::SurfaceId surface_id;
-    std::swap(surface_id, surface_id_);
-    surface_factory_->Destroy(surface_id);
-  }
-  view_.SetLayer(nullptr);
-}
-
 void RenderWidgetHostViewAndroid::CheckOutputSurfaceChanged(
     uint32_t output_surface_id) {
   if (output_surface_id == last_output_surface_id_)
     return;
-  DestroyDelegatedContent();
-  surface_factory_.reset();
+  delegated_frame_host_->OutputSurfaceChanged();
+
   if (!surface_returned_resources_.empty())
     SendReclaimCompositorResources(last_output_surface_id_,
                                    false /* is_swap_ack */);
 
   last_output_surface_id_ = output_surface_id;
 }
 
-void RenderWidgetHostViewAndroid::SubmitCompositorFrame(
-    cc::CompositorFrame frame) {
-  cc::SurfaceManager* manager =
-      ui::ContextProviderFactory::GetInstance()->GetSurfaceManager();
-  if (!surface_factory_) {
-    surface_factory_ = base::WrapUnique(new cc::SurfaceFactory(manager, this));
-  }
-  if (surface_id_.is_null() ||
-      texture_size_in_layer_ != current_surface_size_ ||
-      location_bar_content_translation_ !=
-          frame.metadata.location_bar_content_translation ||
-      current_viewport_selection_ != frame.metadata.selection) {
-    RemoveLayers();
-    if (!surface_id_.is_null())
-      surface_factory_->Destroy(surface_id_);
-    surface_id_ = id_allocator_->GenerateId();
-    surface_factory_->Create(surface_id_);
-    view_.SetLayer(CreateSurfaceLayer(surface_id_, texture_size_in_layer_));
-
-    DCHECK(view_.GetLayer());
-
-    current_surface_size_ = texture_size_in_layer_;
-    location_bar_content_translation_ =
-        frame.metadata.location_bar_content_translation;
-    current_viewport_selection_ = frame.metadata.selection;
-    AttachLayers();
-  }
-
-  cc::SurfaceFactory::DrawCallback ack_callback =
-      base::Bind(&RenderWidgetHostViewAndroid::RunAckCallbacks,
-                 weak_ptr_factory_.GetWeakPtr());
-  surface_factory_->SubmitCompositorFrame(surface_id_, std::move(frame),
-                                          ack_callback);
-}
-
 void RenderWidgetHostViewAndroid::InternalSwapCompositorFrame(
     uint32_t output_surface_id,
     cc::CompositorFrame frame) {
   last_scroll_offset_ = frame.metadata.root_scroll_offset;
   DCHECK(frame.delegated_frame_data);
+  DCHECK(delegated_frame_host_);
 
   if (locks_on_frame_count_ > 0) {
     DCHECK(HasValidFrame());
     RetainFrame(output_surface_id, std::move(frame));
     return;
   }
 
   DCHECK(!frame.delegated_frame_data->render_pass_list.empty());
 
   cc::RenderPass* root_pass =
       frame.delegated_frame_data->render_pass_list.back().get();
-  texture_size_in_layer_ = root_pass->output_rect.size();
+  current_surface_size_ = root_pass->output_rect.size();
 
   cc::CompositorFrameMetadata metadata = frame.metadata.Clone();
 
   CheckOutputSurfaceChanged(output_surface_id);
-  bool has_content = !texture_size_in_layer_.IsEmpty();
+  bool has_content = !current_surface_size_.IsEmpty();
 
   base::Closure ack_callback =
       base::Bind(&RenderWidgetHostViewAndroid::SendReclaimCompositorResources,
                  weak_ptr_factory_.GetWeakPtr(), output_surface_id,
                  true /* is_swap_ack */);
 
   ack_callbacks_.push(ack_callback);
 
   if (!has_content) {
-    DestroyDelegatedContent();
+    delegated_frame_host_->DestroyDelegatedContent();
   } else {
-    SubmitCompositorFrame(std::move(frame));
-    view_.GetLayer()->SetIsDrawable(true);
-    view_.GetLayer()->SetContentsOpaque(true);
-    view_.GetLayer()->SetBounds(texture_size_in_layer_);
+    cc::SurfaceFactory::DrawCallback ack_callback =
+        base::Bind(&RenderWidgetHostViewAndroid::RunAckCallbacks,
+                   weak_ptr_factory_.GetWeakPtr());
+    delegated_frame_host_->SubmitCompositorFrame(std::move(frame),
+                                                 ack_callback);
   }
 
   if (host_->is_hidden())
     RunAckCallbacks();
   frame_evictor_->SwappedFrame(!host_->is_hidden());
 
   // As the metadata update may trigger view invalidation, always call it after
   // any potential compositor scheduling.
   OnFrameMetadataUpdated(std::move(metadata));
 }
 
 void RenderWidgetHostViewAndroid::OnSwapCompositorFrame(
     uint32_t output_surface_id,
     cc::CompositorFrame frame) {
   InternalSwapCompositorFrame(output_surface_id, std::move(frame));
 }
 
 void RenderWidgetHostViewAndroid::ClearCompositorFrame() {
-  DestroyDelegatedContent();
+  delegated_frame_host_->DestroyDelegatedContent();
 }
 
 void RenderWidgetHostViewAndroid::RetainFrame(uint32_t output_surface_id,
                                               cc::CompositorFrame frame) {
   DCHECK(locks_on_frame_count_);
 
   // Store the incoming frame so that it can be swapped when all the locks have
   // been released. If there is already a stored frame, then replace and skip
   // the previous one but make sure we still eventually send the ACK. Holding
   // the ACK also blocks the renderer when its max_frames_pending is reached.
@@ skipping 28 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(
             &RenderFrameDevToolsAgentHost::SynchronousSwapCompositorFrame,
             static_cast<RenderFrameDevToolsAgentHost*>(dtah.get()),
             base::Passed(&frame_metadata)));
   }
 }
 
 void RenderWidgetHostViewAndroid::SetOverlayVideoMode(bool enabled) {
-  if (view_.GetLayer())
-    view_.GetLayer()->SetContentsOpaque(!enabled);
+  if (delegated_frame_host_)
+    delegated_frame_host_->SetContentsOpaque(!enabled);
 }
 
 bool RenderWidgetHostViewAndroid::SupportsAnimation() const {
   // The synchronous (WebView) compositor does not have a proper browser
   // compositor with which to drive animations.
   return using_browser_compositor_;
 }
 
 void RenderWidgetHostViewAndroid::SetNeedsAnimate() {
   DCHECK(content_view_core_ && content_view_core_->GetWindowAndroid());
@@ skipping 50 matching lines @@
       content_view_core_->GetContext().obj()));
 }
 
 void RenderWidgetHostViewAndroid::SynchronousCopyContents(
     const gfx::Rect& src_subrect_in_pixel,
     const gfx::Size& dst_size_in_pixel,
     const ReadbackRequestCallback& callback,
     const SkColorType color_type) {
   gfx::Size input_size_in_pixel;
   if (src_subrect_in_pixel.IsEmpty())
-    input_size_in_pixel = texture_size_in_layer_;
+    input_size_in_pixel = current_surface_size_;
   else
     input_size_in_pixel = src_subrect_in_pixel.size();
 
   gfx::Size output_size_in_pixel;
   if (dst_size_in_pixel.IsEmpty())
     output_size_in_pixel = input_size_in_pixel;
   else
     output_size_in_pixel = dst_size_in_pixel;
   int output_width = output_size_in_pixel.width();
   int output_height = output_size_in_pixel.height();
@@ skipping 72 matching lines @@
 }
 
 void RenderWidgetHostViewAndroid::ShowInternal() {
   bool show = is_showing_ && is_window_activity_started_ && is_window_visible_;
   if (!show)
     return;
 
   if (!host_ || !host_->is_hidden())
     return;
 
-  if (view_.GetLayer())
-    view_.GetLayer()->SetHideLayerAndSubtree(false);
+  view_.GetLayer()->SetHideLayerAndSubtree(false);
 
   frame_evictor_->SetVisible(true);
 
   if (overscroll_controller_)
     overscroll_controller_->Enable();
 
   host_->WasShown(ui::LatencyInfo());
 
   if (content_view_core_) {
     StartObservingRootWindow();
     RequestVSyncUpdate(BEGIN_FRAME);
   }
 }
 
 void RenderWidgetHostViewAndroid::HideInternal() {
   DCHECK(!is_showing_ || !is_window_activity_started_ || !is_window_visible_)
       << "Hide called when the widget should be shown.";
 
   // Only preserve the frontbuffer if the activity was stopped while the
   // window is still visible. This avoids visual artificts when transitioning
   // between activities.
   bool hide_frontbuffer = is_window_activity_started_ || !is_window_visible_;
 
   // Only stop observing the root window if the widget has been explicitly
   // hidden and the frontbuffer is being cleared. This allows window visibility
   // notifications to eventually clear the frontbuffer.
   bool stop_observing_root_window = !is_showing_ && hide_frontbuffer;
 
   if (hide_frontbuffer) {
-    if (view_.GetLayer() && locks_on_frame_count_ == 0)
+    if (locks_on_frame_count_ == 0)

[Khushal, 2016/08/16 06:22:42]

Btw, why is there a locks check here?

[Khushal, 2016/08/16 18:37:36]

Pingy!

[no sievers, 2016/08/16 20:36:36]

I'm about to remove the locking code here as it started scaring me. I already
removed the call sites so it's unused now and should always be 0.

       view_.GetLayer()->SetHideLayerAndSubtree(true);
 
     frame_evictor_->SetVisible(false);
   }
 
   if (stop_observing_root_window) {
     DCHECK(!is_showing_);
     StopObservingRootWindow();
   }
 
   if (!host_ || host_->is_hidden())
     return;
 
   if (overscroll_controller_)
     overscroll_controller_->Disable();
 
   RunAckCallbacks();
 
   // Inform the renderer that we are being hidden so it can reduce its resource
   // utilization.
   host_->WasHidden();
 }
 
-void RenderWidgetHostViewAndroid::AttachLayers() {
-  if (!content_view_core_)
-    return;
-  if (!view_.GetLayer())
-    return;
-
-  content_view_core_->AttachLayer(view_.GetLayer());
-  view_.GetLayer()->SetHideLayerAndSubtree(!is_showing_);
-}
-
-void RenderWidgetHostViewAndroid::RemoveLayers() {
-  if (!content_view_core_)
-    return;
-
-  if (!view_.GetLayer())
-    return;
-
-  content_view_core_->RemoveLayer(view_.GetLayer());
-}
-
 void RenderWidgetHostViewAndroid::RequestVSyncUpdate(uint32_t requests) {
   bool should_request_vsync = !outstanding_vsync_requests_ && requests;
   outstanding_vsync_requests_ |= requests;
 
   // Note that if we're not currently observing the root window, outstanding
   // vsync requests will be pushed if/when we resume observing in
   // |StartObservingRootWindow()|.
   if (observing_root_window_ && should_request_vsync)
     content_view_core_->GetWindowAndroid()->RequestVSyncUpdate();
 }
@@ skipping 66 matching lines @@
 }
 
 void RenderWidgetHostViewAndroid::RequestDisallowInterceptTouchEvent() {
   if (content_view_core_)
     content_view_core_->RequestDisallowInterceptTouchEvent();
 }
 
 void RenderWidgetHostViewAndroid::EvictDelegatedFrame() {
   DCHECK_EQ(locks_on_frame_count_, 0u);
   frame_evictor_->DiscardedFrame();
-  if (view_.GetLayer())
-    DestroyDelegatedContent();
+  delegated_frame_host_->DestroyDelegatedContent();
 }
 
 bool RenderWidgetHostViewAndroid::HasAcceleratedSurface(
     const gfx::Size& desired_size) {
   NOTREACHED();
   return false;
 }
 
 // TODO(jrg): Find out the implications and answer correctly here,
 // as we are returning the WebView and not root window bounds.
@@ skipping 184 matching lines @@
 
 SkColor RenderWidgetHostViewAndroid::GetCachedBackgroundColor() const {
   return cached_background_color_;
 }
 
 void RenderWidgetHostViewAndroid::DidOverscroll(
     const DidOverscrollParams& params) {
   if (sync_compositor_)
     sync_compositor_->DidOverscroll(params);
 
-  if (!content_view_core_ || !view_.GetLayer() || !is_showing_)
+  if (!content_view_core_ || !is_showing_)
+    return;
+
+  if (delegated_frame_host_ && delegated_frame_host_->HasDelegatedContent())
     return;
 
   if (overscroll_controller_)
     overscroll_controller_->OnOverscrolled(params);
 }
 
 void RenderWidgetHostViewAndroid::DidStopFlinging() {
   if (content_view_core_)
     content_view_core_->DidStopFlinging();
 }
 
 uint32_t RenderWidgetHostViewAndroid::GetSurfaceClientId() {
-  if (id_allocator_)
-    return id_allocator_->client_id();
-  return 0;
+  if (!delegated_frame_host_)
+    return 0;
+
+  return delegated_frame_host_->GetSurfaceClientId();
 }
 
 void RenderWidgetHostViewAndroid::SetContentViewCore(
     ContentViewCoreImpl* content_view_core) {
   DCHECK(!content_view_core || !content_view_core_ ||
          (content_view_core_ == content_view_core));
-  RemoveLayers();
   StopObservingRootWindow();
 
   bool resize = false;
   if (content_view_core != content_view_core_) {
     overscroll_controller_.reset();
     selection_controller_.reset();
     ReleaseLocksOnSurface();
     // TODO(yusufo) : Get rid of the below conditions and have a better handling
     // for resizing after crbug.com/628302 is handled.
     bool is_size_initialized = !content_view_core
         || content_view_core->GetViewportSizeDip().width() != 0
         || content_view_core->GetViewportSizeDip().height() != 0;
     if (content_view_core_ || is_size_initialized)
       resize = true;
     if (content_view_core_) {
       content_view_core_->RemoveObserver(this);
       view_.RemoveFromParent();
+      view_.GetLayer()->RemoveFromParent();
     }
     if (content_view_core) {
       content_view_core->AddObserver(this);
-      content_view_core->GetViewAndroid()->AddChild(&view_);
+      ui::ViewAndroid* parent_view = content_view_core->GetViewAndroid();
+      parent_view->AddChild(&view_);
+      parent_view->GetLayer()->AddChild(view_.GetLayer());
     }
     content_view_core_ = content_view_core;
   }
 
   BrowserAccessibilityManager* manager = NULL;
   if (host_)
     manager = host_->GetRootBrowserAccessibilityManager();
   if (manager) {
     base::android::ScopedJavaLocalRef<jobject> obj;
     if (content_view_core_)
       obj = content_view_core_->GetJavaObject();
     manager->ToBrowserAccessibilityManagerAndroid()->SetContentViewCore(obj);
   }
 
-  AttachLayers();
   if (!content_view_core_) {
     sync_compositor_.reset();
     return;
   }
 
   if (is_showing_)
     StartObservingRootWindow();
 
   if (resize)
     WasResized();
@@ skipping 124 matching lines @@
 
 void RenderWidgetHostViewAndroid::OnActivityStarted() {
   TRACE_EVENT0("browser", "RenderWidgetHostViewAndroid::OnActivityStarted");
   DCHECK(observing_root_window_);
   is_window_activity_started_ = true;
   ShowInternal();
 }
 
 void RenderWidgetHostViewAndroid::OnLostResources() {
   ReleaseLocksOnSurface();
-  if (view_.GetLayer())
-    DestroyDelegatedContent();
+  delegated_frame_host_->DestroyDelegatedContent();
   DCHECK(ack_callbacks_.empty());
 }
 
 // TODO(wjmaclean): There is significant overlap between
 // PrepareTextureCopyOutputResult and CopyFromCompositingSurfaceFinished in
 // this file, and the versions in surface_utils.cc. They should
 // be merged. See https://crbug.com/582955
 
 // static
 void RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResult(
-    base::WeakPtr<RenderWidgetHostViewAndroid> rwhva,
-    scoped_refptr<cc::Layer> readback_layer,
     const gfx::Size& dst_size_in_pixel,
     SkColorType color_type,
     const base::TimeTicks& start_time,
     const ReadbackRequestCallback& callback,
     std::unique_ptr<cc::CopyOutputResult> result) {
   base::ScopedClosureRunner scoped_callback_runner(
       base::Bind(callback, SkBitmap(), READBACK_FAILED));
   TRACE_EVENT0("cc",
                "RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResult");
-  readback_layer->RemoveFromParent();
   if (!result->HasTexture() || result->IsEmpty() || result->size().IsEmpty())
     return;
   cc::TextureMailbox texture_mailbox;
   std::unique_ptr<cc::SingleReleaseCallback> release_callback;
   result->TakeTexture(&texture_mailbox, &release_callback);
   DCHECK(texture_mailbox.IsTexture());
   if (!texture_mailbox.IsTexture())
     return;
   display_compositor::GLHelper* gl_helper = GetPostReadbackGLHelper();
   if (!gl_helper)
@@ skipping 76 matching lines @@
     case ui::MotionEvent::ACTION_UP:
     case ui::MotionEvent::ACTION_POINTER_UP:
       UMA_HISTOGRAM_CUSTOM_COUNTS("Event.Latency.OS.TOUCH_RELEASED",
                                   delta.InMicroseconds(), 1, 1000000, 50);
     default:
       return;
   }
 }
 
 }  // namespace content