Android: Remove some dead code

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>
 
@@ skipping 266 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 = CompositorImpl::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 126 matching lines @@
   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);
 }
 
-scoped_refptr<cc::Layer> RenderWidgetHostViewAndroid::CreateDelegatedLayer()
-    const {
-  scoped_refptr<cc::Layer> delegated_layer;
-  DCHECK(!surface_id_.is_null());
-  cc::SurfaceManager* manager = CompositorImpl::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, texture_size_in_layer_);
-  delegated_layer = surface_layer;
-  delegated_layer->SetBounds(texture_size_in_layer_);
-  delegated_layer->SetIsDrawable(true);
-  delegated_layer->SetContentsOpaque(true);
-
-  return delegated_layer;
-}
-
 bool RenderWidgetHostViewAndroid::HasValidFrame() const {
   if (!content_view_core_)
     return false;
   if (!layer_.get())
     return false;
 
   if (texture_size_in_layer_.IsEmpty())
     return false;
   // This tell us whether a valid frame has arrived or not.
   if (!frame_evictor_->HasFrame())
@@ skipping 540 matching lines @@
   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_);
-    layer_ = CreateDelegatedLayer();
+    layer_ = CreateSurfaceLayer(surface_id_, texture_size_in_layer_);
 
     DCHECK(layer_);
 
     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::SwapDelegatedFrame(
+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(CompositorImpl::GetSurfaceManager());
+
+  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();
+
+  cc::CompositorFrameMetadata metadata = frame.metadata.Clone();
+
   CheckOutputSurfaceChanged(output_surface_id);
   bool has_content = !texture_size_in_layer_.IsEmpty();
 
   base::Closure ack_callback =
       base::Bind(&RenderWidgetHostViewAndroid::SendDelegatedFrameAck,
                  weak_ptr_factory_.GetWeakPtr(),
                  output_surface_id);
 
   ack_callbacks_.push(ack_callback);
 
   if (!has_content) {
     DestroyDelegatedContent();
   } else {
     SubmitCompositorFrame(std::move(frame));
-  }
-
-  if (layer_.get()) {
     layer_->SetIsDrawable(true);
     layer_->SetContentsOpaque(true);
     layer_->SetBounds(texture_size_in_layer_);
   }
 
   if (host_->is_hidden())
     RunAckCallbacks(cc::SurfaceDrawStatus::DRAW_SKIPPED);
-}
-
-void RenderWidgetHostViewAndroid::InternalSwapCompositorFrame(
-    uint32_t output_surface_id,
-    cc::CompositorFrame frame) {
-  last_scroll_offset_ = frame.metadata.root_scroll_offset;
-  if (!frame.delegated_frame_data) {
-    LOG(ERROR) << "Non-delegated renderer path no longer supported";
-    return;
-  }
-
-  if (locks_on_frame_count_ > 0) {
-    DCHECK(HasValidFrame());
-    RetainFrame(output_surface_id, std::move(frame));
-    return;
-  }
-
-  if (!CompositorImpl::GetSurfaceManager() && layer_.get() &&
-      layer_->layer_tree_host()) {
-    for (size_t i = 0; i < frame.metadata.latency_info.size(); i++) {
-      std::unique_ptr<cc::SwapPromise> swap_promise(
-          new cc::LatencyInfoSwapPromise(frame.metadata.latency_info[i]));
-      layer_->layer_tree_host()->QueueSwapPromise(std::move(swap_promise));
-    }
-  }
-
-  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();
-
-  cc::CompositorFrameMetadata metadata = frame.metadata.Clone();
-
-  SwapDelegatedFrame(output_surface_id, std::move(frame));
   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) {
@@ skipping 909 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