Android WebView: fix missing an invalidate

When webview translates into the screen from offscreen by calling
WebView#SetTranslateX/Y, onDrawHardware is called with an empty global
visible rect.
When the webview is still offscreen, Android frameworks won't call
DrawGL on WebView, which means the "parent draw constraints" stored in
hardware renderer won't contain the draw constraints when the webview is
offscreen.
When webview gets an ondraw with an empty global visible rect, we need
to make sure the parent draw constraints of the corresponding DrawGL is
always posted back to child compositor and triggers an invalidate.

BUG=417479

Review URL: https://codereview.chromium.org/603633003

Cr-Commit-Position: refs/heads/master@{#296589}

android_webview/browser/browser_view_renderer.cc

@@ -258,6 +258,7 @@ bool BrowserViewRenderer::OnDrawHardware(jobject java_canvas) {
     TRACE_EVENT_INSTANT0("android_webview",
                          "EarlyOut_EmptyVisibleRect",
                          TRACE_EVENT_SCOPE_THREAD);
+    shared_renderer_state_->SetForceInvalidateOnNextDrawGL(true);
     return client_->RequestDrawGL(java_canvas, false);
   }
 
@@ -326,9 +327,12 @@ bool BrowserViewRenderer::OnDrawHardware(jobject java_canvas) {
 void BrowserViewRenderer::UpdateParentDrawConstraints() {
   // Post an invalidate if the parent draw constraints are stale and there is
   // no pending invalidate.
-  if (!parent_draw_constraints_.Equals(
-          shared_renderer_state_->ParentDrawConstraints()))
+  if (shared_renderer_state_->NeedsForceInvalidateOnNextDrawGL() ||
+      !parent_draw_constraints_.Equals(
+        shared_renderer_state_->ParentDrawConstraints())) {
+    shared_renderer_state_->SetForceInvalidateOnNextDrawGL(false);
     EnsureContinuousInvalidation(true);
+  }
 }
 
 void BrowserViewRenderer::ReturnUnusedResource(scoped_ptr<DrawGLInput> input) {

android_webview/browser/hardware_renderer.cc

@@ -216,11 +216,10 @@ void HardwareRenderer::DrawGL(bool stencil_enabled,
   // compositor might not have the tiles rasterized as the animation goes on.
   ParentCompositorDrawConstraints draw_constraints(
       draw_info->is_layer, transform, gfx::Rect(viewport_));
-  if (!draw_constraints_.Equals(draw_constraints)) {
+
   draw_constraints_ = draw_constraints;
   shared_renderer_state_->PostExternalDrawConstraintsToChildCompositor(
       draw_constraints);
-  }
 
   if (!delegated_layer_.get())
     return;

android_webview/browser/shared_renderer_state.cc

@@ -79,7 +79,8 @@ SharedRendererState::SharedRendererState(
     : ui_loop_(ui_loop),
       client_on_ui_(client),
       inside_hardware_release_(false),
-      weak_factory_on_ui_thread_(this){
+      needs_force_invalidate_on_next_draw_gl_(false),
+      weak_factory_on_ui_thread_(this) {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   DCHECK(client_on_ui_);
   ui_thread_weak_ptr_ = weak_factory_on_ui_thread_.GetWeakPtr();
@@ -150,21 +151,27 @@ scoped_ptr<DrawGLInput> SharedRendererState::PassDrawGLInput() {
   return draw_gl_input_.Pass();
 }
 
-void SharedRendererState::UpdateDrawConstraints(
+bool SharedRendererState::UpdateDrawConstraints(
     const ParentCompositorDrawConstraints& parent_draw_constraints) {
   base::AutoLock lock(lock_);
+  if (needs_force_invalidate_on_next_draw_gl_ ||
+      !parent_draw_constraints_.Equals(parent_draw_constraints)) {
     parent_draw_constraints_ = parent_draw_constraints;
+    return true;
+  }
+
+  return false;
 }
 
 void SharedRendererState::PostExternalDrawConstraintsToChildCompositor(
     const ParentCompositorDrawConstraints& parent_draw_constraints) {
-  UpdateDrawConstraints(parent_draw_constraints);
-
+  if (UpdateDrawConstraints(parent_draw_constraints)) {
     // No need to hold the lock_ during the post task.
     ui_loop_->PostTask(
         FROM_HERE,
         base::Bind(&SharedRendererState::UpdateParentDrawConstraintsOnUIThread,
                    ui_thread_weak_ptr_));
+  }
 }
 
 const ParentCompositorDrawConstraints
@@ -173,6 +180,18 @@ SharedRendererState::ParentDrawConstraints() const {
   return parent_draw_constraints_;
 }
 
+void SharedRendererState::SetForceInvalidateOnNextDrawGL(
+    bool needs_force_invalidate_on_next_draw_gl) {
+  base::AutoLock lock(lock_);
+  needs_force_invalidate_on_next_draw_gl_ =
+      needs_force_invalidate_on_next_draw_gl;
+}
+
+bool SharedRendererState::NeedsForceInvalidateOnNextDrawGL() const {
+  base::AutoLock lock(lock_);
+  return needs_force_invalidate_on_next_draw_gl_;
+}
+
 void SharedRendererState::SetInsideHardwareRelease(bool inside) {
   base::AutoLock lock(lock_);
   inside_hardware_release_ = inside;

android_webview/browser/shared_renderer_state.h

@@ -58,13 +58,18 @@ class SharedRendererState {
   scoped_ptr<DrawGLInput> PassDrawGLInput();
 
   bool IsInsideHardwareRelease() const;
-  void UpdateDrawConstraints(
+  // Returns true if the draw constraints are updated.
+  bool UpdateDrawConstraints(
       const ParentCompositorDrawConstraints& parent_draw_constraints);
   void PostExternalDrawConstraintsToChildCompositor(
       const ParentCompositorDrawConstraints& parent_draw_constraints);
 
   const ParentCompositorDrawConstraints ParentDrawConstraints() const;
 
+  void SetForceInvalidateOnNextDrawGL(
+      bool needs_force_invalidate_on_next_draw_gl);
+  bool NeedsForceInvalidateOnNextDrawGL() const;
+
   void InsertReturnedResources(const cc::ReturnedResourceArray& resources);
   void SwapReturnedResources(cc::ReturnedResourceArray* resources);
   bool ReturnedResourcesEmpty() const;
@@ -87,6 +92,7 @@ class SharedRendererState {
   mutable base::Lock lock_;
   scoped_ptr<DrawGLInput> draw_gl_input_;
   bool inside_hardware_release_;
+  bool needs_force_invalidate_on_next_draw_gl_;
   ParentCompositorDrawConstraints parent_draw_constraints_;
   cc::ReturnedResourceArray returned_resources_;
   base::Closure request_draw_gl_closure_;