Remove android webview rendering cruft

android_webview/browser/hardware_renderer.cc

 // Copyright 2014 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 "android_webview/browser/hardware_renderer.h"
 
 #include "android_webview/browser/aw_gl_surface.h"
 #include "android_webview/browser/deferred_gpu_command_service.h"
 #include "android_webview/browser/parent_output_surface.h"
 #include "android_webview/browser/shared_renderer_state.h"
@@ skipping 91 matching lines @@
   settings.single_thread_proxy_scheduler = false;
 
   layer_tree_host_ = cc::LayerTreeHost::CreateSingleThreaded(
       this, this, nullptr, nullptr, settings, nullptr, nullptr);
   layer_tree_host_->SetRootLayer(root_layer_);
   layer_tree_host_->SetLayerTreeHostClientReady();
   layer_tree_host_->set_has_transparent_background(true);
 }
 
 HardwareRenderer::~HardwareRenderer() {
-  SetFrameData();
-
   // Must reset everything before |resource_collection_| to ensure all
   // resources are returned before resetting |resource_collection_| client.
   layer_tree_host_.reset();
   root_layer_ = NULL;
   delegated_layer_ = NULL;
   frame_provider_ = NULL;
 #if DCHECK_IS_ON()
   // Check collection is empty.
   cc::ReturnedResourceArray returned_resources;
   resource_collection_->TakeUnusedResourcesForChildCompositor(
@@ skipping 13 matching lines @@
   // starts. We set the draw constraints here.
   DCHECK(output_surface_);
   DCHECK(viewport_clip_valid_for_dcheck_);
   output_surface_->SetExternalStencilTest(stencil_enabled_);
   output_surface_->SetDrawConstraints(viewport_, clip_);
 }
 
 void HardwareRenderer::CommitFrame() {
   TRACE_EVENT0("android_webview", "CommitFrame");
   scroll_offset_ = shared_renderer_state_->GetScrollOffsetOnRT();
-  if (committed_frame_.get()) {
-    TRACE_EVENT_INSTANT0("android_webview",
-                         "EarlyOut_PreviousFrameUnconsumed",
-                         TRACE_EVENT_SCOPE_THREAD);
-    shared_renderer_state_->DidSkipCommitFrameOnRT();
-    return;
-  }
-
-  committed_frame_ = shared_renderer_state_->PassCompositorFrameOnRT();
+  scoped_ptr<cc::CompositorFrame> frame =
+      shared_renderer_state_->PassCompositorFrameOnRT();
   // Happens with empty global visible rect.

[hush (inactive), 2015/03/13 18:45:17]

Remove this comment here? because an empty globall visible rect does not mean
the produced frame is empty.

[boliu, 2015/03/18 02:02:22]

Removed comment, but still need that check. We want to move in a direction where
child compositor is free to not swap if it doesn't want to.

-  if (!committed_frame_.get())
+  if (!frame.get())
     return;
 
-  DCHECK(!committed_frame_->gl_frame_data);
-  DCHECK(!committed_frame_->software_frame_data);
+  DCHECK(!frame->gl_frame_data);
+  DCHECK(!frame->software_frame_data);
 
   // DelegatedRendererLayerImpl applies the inverse device_scale_factor of the
   // renderer frame, assuming that the browser compositor will scale
   // it back up to device scale.  But on Android we put our browser layers in
   // physical pixels and set our browser CC device_scale_factor to 1, so this
   // suppresses the transform.
-  committed_frame_->delegated_frame_data->device_scale_factor = 1.0f;
-}
+  frame->delegated_frame_data->device_scale_factor = 1.0f;
 
-void HardwareRenderer::SetFrameData() {
-  if (!committed_frame_.get())
-    return;
-
-  scoped_ptr<cc::CompositorFrame> frame = committed_frame_.Pass();
   gfx::Size frame_size =
       frame->delegated_frame_data->render_pass_list.back()->output_rect.size();
   bool size_changed = frame_size != frame_size_;
   frame_size_ = frame_size;
 
   if (!frame_provider_.get() || size_changed) {
     if (delegated_layer_.get()) {
       delegated_layer_->RemoveFromParent();
     }
 
@@ skipping 17 matching lines @@
 
   // We need to watch if the current Android context has changed and enforce
   // a clean-up in the compositor.
   EGLContext current_context = eglGetCurrentContext();
   DCHECK(current_context) << "DrawGL called without EGLContext";
 
   // TODO(boliu): Handle context loss.
   if (last_egl_context_ != current_context)
     DLOG(WARNING) << "EGLContextChanged";
 
-  SetFrameData();
-  if (shared_renderer_state_->ForceCommitOnRT()) {
-    CommitFrame();
-    SetFrameData();
-  }
-
   gfx::Transform transform(gfx::Transform::kSkipInitialization);
   transform.matrix().setColMajorf(draw_info->transform);
   transform.Translate(scroll_offset_.x(), scroll_offset_.y());
 
   // Need to post the new transform matrix back to child compositor
   // because there is no onDraw during a Render Thread animation, and child
   // compositor might not have the tiles rasterized as the animation goes on.
   ParentCompositorDrawConstraints draw_constraints(
       draw_info->is_layer, transform, gfx::Rect(viewport_));
 
@@ skipping 39 matching lines @@
 }
 
 void HardwareRenderer::UnusedResourcesAreAvailable() {
   cc::ReturnedResourceArray returned_resources;
   resource_collection_->TakeUnusedResourcesForChildCompositor(
       &returned_resources);
   shared_renderer_state_->InsertReturnedResourcesOnRT(returned_resources);
 }
 
 }  // namespace android_webview