Avoid scheduling unnecessary ProcessGL between GL draws.

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/aw_render_thread_context_provider.h"
 #include "android_webview/browser/child_frame.h"
 #include "android_webview/browser/deferred_gpu_command_service.h"
@@ skipping 55 matching lines @@
   surface_factory_.reset();
 
   // Reset draw constraints.
   shared_renderer_state_->PostExternalDrawConstraintsToChildCompositorOnRT(
       ParentCompositorDrawConstraints());
 }
 
 void HardwareRenderer::CommitFrame() {
   TRACE_EVENT0("android_webview", "CommitFrame");
   scroll_offset_ = shared_renderer_state_->GetScrollOffsetOnRT();
-  {
-    scoped_ptr<ChildFrame> child_frame =
-        shared_renderer_state_->PassCompositorFrameOnRT();
-    if (!child_frame.get())
-      return;
-    child_frame_ = child_frame.Pass();
-  }
-
-  scoped_ptr<cc::CompositorFrame> frame = child_frame_->frame.Pass();
-  DCHECK(frame.get());
-  DCHECK(!frame->gl_frame_data);
-
-  // On Android we put our browser layers in physical pixels and set our
-  // browser CC device_scale_factor to 1, so suppress the transform between
-  // DIP and pixels.
-  frame->delegated_frame_data->device_scale_factor = 1.0f;
-
-  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 (child_id_.is_null() || size_changed) {
-    if (!child_id_.is_null())
-      surface_factory_->Destroy(child_id_);
-    child_id_ = surface_id_allocator_->GenerateId();
-    surface_factory_->Create(child_id_);
-  }
-
-  surface_factory_->SubmitCompositorFrame(child_id_, frame.Pass(),
-                                          cc::SurfaceFactory::DrawCallback());
+  scoped_ptr<ChildFrame> child_frame =
+      shared_renderer_state_->PassCompositorFrameOnRT();
+  if (!child_frame.get())
+    return;
+  child_frame_ = child_frame.Pass();
+  DCHECK(child_frame_->frame.get());
+  DCHECK(!child_frame_->frame->gl_frame_data);
 }
 
 void HardwareRenderer::DrawGL(bool stencil_enabled,
                               AwDrawGLInfo* draw_info) {
   TRACE_EVENT0("android_webview", "HardwareRenderer::DrawGL");
 
   // 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";
 
+  // SurfaceFactory::SubmitCompositorFrame might call glFlush. So calling it
+  // during "kModeSync" stage (which does not allow GL) might result in extra
+  // kModeProcess. Instead, submit the frame in "kModeDraw" stage to avoid
+  // unnecessary kModeProcess.
+  scoped_ptr<ChildFrame> child_frame = child_frame_.Pass();
+  if (child_frame.get()) {
+    scoped_ptr<cc::CompositorFrame> child_compositor_frame =
+        child_frame->frame.Pass();
+
+    // On Android we put our browser layers in physical pixels and set our
+    // browser CC device_scale_factor to 1, so suppress the transform between
+    // DIP and pixels.
+    child_compositor_frame->delegated_frame_data->device_scale_factor = 1.0f;
+
+    gfx::Size frame_size =
+        child_compositor_frame->delegated_frame_data->render_pass_list.back()
+            ->output_rect.size();
+    bool size_changed = frame_size != frame_size_;
+    frame_size_ = frame_size;
+    if (child_id_.is_null() || size_changed) {
+      if (!child_id_.is_null())
+        surface_factory_->Destroy(child_id_);
+      child_id_ = surface_id_allocator_->GenerateId();
+      surface_factory_->Create(child_id_);
+    }
+
+    surface_factory_->SubmitCompositorFrame(child_id_,
+                                            child_compositor_frame.Pass(),
+                                            cc::SurfaceFactory::DrawCallback());
+  }
+
   gfx::Transform transform(gfx::Transform::kSkipInitialization);
   transform.matrix().setColMajorf(draw_info->transform);
   transform.Translate(scroll_offset_.x(), scroll_offset_.y());
 
   gfx::Size viewport(draw_info->width, draw_info->height);
   // 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, viewport.IsEmpty());
-  if (!child_frame_.get() || draw_constraints.NeedUpdate(*child_frame_)) {
+  if (!child_frame.get() || draw_constraints.NeedUpdate(*child_frame)) {
     shared_renderer_state_->PostExternalDrawConstraintsToChildCompositorOnRT(
         draw_constraints);
   }
 
   if (child_id_.is_null())
     return;
 
   gfx::Rect clip(draw_info->clip_left, draw_info->clip_top,
                  draw_info->clip_right - draw_info->clip_left,
                  draw_info->clip_bottom - draw_info->clip_top);
@@ skipping 50 matching lines @@
     const cc::ReturnedResourceArray& resources) {
   shared_renderer_state_->InsertReturnedResourcesOnRT(resources);
 }
 
 void HardwareRenderer::SetBackingFrameBufferObject(
     int framebuffer_binding_ext) {
   gl_surface_->SetBackingFrameBufferObject(framebuffer_binding_ext);
 }
 
 }  // namespace android_webview