aw: Add and use DrawGL kModeSync

android_webview/native/aw_contents.cc

 // Copyright 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 "android_webview/native/aw_contents.h"
 
 #include <limits>
 
 #include "android_webview/browser/aw_browser_context.h"
 #include "android_webview/browser/aw_browser_main_parts.h"
@@ skipping 324 matching lines @@
 jint GetNativeInstanceCount(JNIEnv* env, jclass) {
   return base::subtle::NoBarrier_Load(&g_instance_count);
 }
 
 jlong AwContents::GetAwDrawGLViewContext(JNIEnv* env, jobject obj) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return reinterpret_cast<intptr_t>(this);
 }
 
 void AwContents::DrawGL(AwDrawGLInfo* draw_info) {
+  if (draw_info->mode == AwDrawGLInfo::kModeSync) {
+    if (hardware_renderer_)
+      hardware_renderer_->CommitFrame();

[hush (inactive), 2014/07/25 18:08:07]

CommitFrame will just copy the child draw result (framedata) to the parent and
recreate the delegated layer in parent if needed.
Then in the next kModeDraw, parent compositor will draw the frame, issue GL
commands, etc.

Do I understand it correctly?

Is the following sequence of events guaranteed?
ondraw --> kModeSync --> kModeDraw

And you always have a 1 to 1 correspondence between kModeSync and kModeDraw,
right?

[boliu, 2014/07/25 18:11:02]

Everything above here is correct.
No. kModeDraw can happen more times compared to kModeSync, it will just keep
drawing the same frame. onDraw and kModeSync are 1-to-1 though.

[hush (inactive), 2014/07/25 18:31:00]

Okay.
Imagine a scenario where onDraw happens every 16ms, but DrawGL is ridiculously
slow.
Without this change, the new frame data that is produced on UI thread just keeps
getting overwritten by the next onDraw because DrawGL is slow and hasn't
finished the previous frame yet. In this case, DrawGL will draw an old frame.

With this change, the parent compositor will always have the most recent
framedata due to kModeSync, so the parent still drop some frames because UI is
producing frames faster than RT can handle, but will always use the most recent
frame when it draws.

Is that right?
On 2014/07/25 18:11:02, boliu wrote:

[boliu, 2014/07/25 18:41:51]

Yes. But "old frame" isn't a good charaterization. It's a two stage pipeline.
Before this change, we advanced the pipeline in DrawGL. So "old frame" just
means the second stage of the pipeline
Can't happen. Remember I said onDraw and kModeSync are 1-to-1. Framework will
block the UI thread after onDraw until kModeSync happens.

+    return;
+  }
+
   {
     GLViewRendererManager* manager = GLViewRendererManager::GetInstance();
     base::AutoLock lock(render_thread_lock_);
     if (renderer_manager_key_ != manager->NullKey()) {
       manager->DidDrawGL(renderer_manager_key_);
     }
   }
 
   ScopedAppGLStateRestore state_restore(
       draw_info->mode == AwDrawGLInfo::kModeDraw
           ? ScopedAppGLStateRestore::MODE_DRAW
           : ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT);
   ScopedAllowGL allow_gl;
 
   if (shared_renderer_state_.IsInsideHardwareRelease()) {
     hardware_renderer_.reset();
     return;
   }
 
   if (draw_info->mode != AwDrawGLInfo::kModeDraw)
     return;
 
   if (!hardware_renderer_) {
     hardware_renderer_.reset(new HardwareRenderer(&shared_renderer_state_));
+    hardware_renderer_->CommitFrame();
   }
 
   hardware_renderer_->DrawGL(state_restore.stencil_enabled(),
                              state_restore.framebuffer_binding_ext(),
                              draw_info);
 }
 
 namespace {
 void DocumentHasImagesCallback(const ScopedJavaGlobalRef<jobject>& message,
                                bool has_images) {
@@ skipping 765 matching lines @@
   }
 
   browser_view_renderer_.TrimMemory(level, visible);
 }
 
 void SetShouldDownloadFavicons(JNIEnv* env, jclass jclazz) {
   g_should_download_favicons = true;
 }
 
 }  // namespace android_webview