aw: Fix lost invalidate while playing video

android_webview/browser/browser_view_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/browser_view_renderer.h"
 
 #include "android_webview/browser/browser_view_renderer_client.h"
 #include "android_webview/browser/shared_renderer_state.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "base/android/jni_android.h"
@@ skipping 646 matching lines @@
   // 1) Webview is paused. Also need to check we are not in clear view since
   // paused, offscreen still expect clear view to recover.
   // 2) If we are attached to window and the window is not visible (eg when
   // app is in the background). We are sure in this case the webview is used
   // "on-screen" but that updates are not needed when in the background.
   bool throttle_fallback_tick =
       (is_paused_ && !clear_view_) || (attached_to_window_ && !window_visible_);
   if (throttle_fallback_tick)
     return;
 
+  base::AutoLock lock(render_thread_lock_);
   block_invalidates_ = compositor_needs_continuous_invalidate_;
 
   // Unretained here is safe because the callback is cancelled when
   // |fallback_tick_| is destroyed.
   fallback_tick_.Reset(base::Bind(&BrowserViewRenderer::FallbackTickFired,
                                   base::Unretained(this)));
 
   // No need to reschedule fallback tick if compositor does not need to be
   // ticked. This can happen if this is reached because force_invalidate is
   // true.
@@ skipping 29 matching lines @@
 
 bool BrowserViewRenderer::CompositeSW(SkCanvas* canvas) {
   DCHECK(has_compositor_);
   bool result = shared_renderer_state_->GetCompositor()->
       DemandDrawSw(canvas);
   DidComposite(false);
   return result;
 }
 
 void BrowserViewRenderer::DidComposite(bool force_invalidate) {
-  fallback_tick_.Cancel();
-  block_invalidates_ = false;
-  EnsureContinuousInvalidation(force_invalidate);
+  {
+    base::AutoLock lock(render_thread_lock_);
+    fallback_tick_.Cancel();

[mkosiba (inactive), 2014/05/12 14:29:51]

this doesn't look threadsafe:

from base/cancellable_callback.h

"CancelableCallback objects must be created on, posted to, cancelled on, and
destroyed on the same thread."

[boliu, 2014/05/12 15:34:49]

Hmm, good point. There is nothing protecting running the callback.

Moved to UI thread instead. Cancelling shouldn't matter other than a few
unnecessary fallback ticks.

+    block_invalidates_ = false;
+  }
+
+  if (ui_task_runner_->BelongsToCurrentThread()) {
+    EnsureContinuousInvalidation(force_invalidate);
+    return;
+  }
+  ui_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&BrowserViewRenderer::EnsureContinuousInvalidation,
+                 ui_thread_weak_ptr_,
+                 force_invalidate));
 }
 
 std::string BrowserViewRenderer::ToString(AwDrawGLInfo* draw_info) const {
   std::string str;
   base::StringAppendF(&str, "is_paused: %d ", is_paused_);
   base::StringAppendF(&str, "view_visible: %d ", view_visible_);
   base::StringAppendF(&str, "window_visible: %d ", window_visible_);
   base::StringAppendF(&str, "dip_scale: %f ", dip_scale_);
   base::StringAppendF(&str, "page_scale_factor: %f ", page_scale_factor_);
   base::StringAppendF(&str,
@@ skipping 23 matching lines @@
     base::StringAppendF(&str,
                         "surface width height: [%d %d] ",
                         draw_info->width,
                         draw_info->height);
     base::StringAppendF(&str, "is_layer: %d ", draw_info->is_layer);
   }
   return str;
 }
 
 }  // namespace android_webview