Unit Test for WebView animating in and out of screen

android_webview/browser/test/fake_window.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/test/fake_window.h"
 
 #include "android_webview/browser/browser_view_renderer.h"
-#include "android_webview/public/browser/draw_gl.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "ui/gl/gl_bindings.h"
 
 namespace android_webview {
 
 class FakeWindow::ScopedMakeCurrent {
  public:
   ScopedMakeCurrent(FakeWindow* view_root) : view_root_(view_root) {
@@ skipping 14 matching lines @@
                    EGL_NO_SURFACE, EGL_NO_CONTEXT);
     view_root_->context_->ReleaseCurrent(view_root_->surface_.get());
   }
 
  private:
   FakeWindow* view_root_;
 };
 
 FakeWindow::FakeWindow(BrowserViewRenderer* view,
                        WindowHooks* hooks,
-                       gfx::Rect location)
+                       gfx::Rect location,
+                       bool will_wait_for_mode_draw_to_finish)
     : view_(view),
       hooks_(hooks),
       surface_size_(100, 100),
+      will_wait_for_mode_draw_to_finish_(will_wait_for_mode_draw_to_finish),
       location_(location),
       on_draw_hardware_pending_(false),
       functor_(nullptr),
       context_current_(false),
       weak_ptr_factory_(this) {
   CheckCurrentlyOnUIThread();
   DCHECK(view_);
   view_->OnAttachedToWindow(location_.width(), location_.height());
   view_->SetWindowVisibility(true);
   view_->SetViewVisibility(true);
@@ skipping 42 matching lines @@
     functor_->DrawGL(&process_info);
   }
   hooks_->DidProcessOnRT(functor_);
 
   if (sync)
     sync->Signal();
 }
 
 void FakeWindow::PostInvalidate() {
   CheckCurrentlyOnUIThread();
-  if (on_draw_hardware_pending_)
+  if (on_draw_hardware_pending_) {
+    if (will_wait_for_mode_draw_to_finish_) {

[boliu, 2015/03/16 20:25:08]

Oh this is what you meant... please no :(

We need a hook for when parent constraints get updated for this test. I guess
you could just add it to BVRClient, just for tests. Or subclassing BVR to
BVRForTesting isn't that bad either; that's what cc does.

+      base::MessageLoopProxy::current()->PostTask(
+          FROM_HERE, base::Bind(&FakeWindow::PostInvalidate,
+                                weak_ptr_factory_.GetWeakPtr()));
+    }
     return;
+  }
   on_draw_hardware_pending_ = true;
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(&FakeWindow::OnDrawHardware, weak_ptr_factory_.GetWeakPtr()));
 }
 
 void FakeWindow::OnDrawHardware() {
   CheckCurrentlyOnUIThread();
   DCHECK(on_draw_hardware_pending_);
-  on_draw_hardware_pending_ = false;
+  if (!will_wait_for_mode_draw_to_finish_)
+    on_draw_hardware_pending_ = false;
 
+  view_->PrepareToDraw(gfx::Vector2d(), location_);
   hooks_->WillOnDraw();
-  view_->PrepareToDraw(gfx::Vector2d(), location_);
   bool success = view_->OnDrawHardware();
   hooks_->DidOnDraw(success);
   if (success) {
     CreateRenderThreadIfNeeded();
 
     base::WaitableEvent completion(true, false);
     render_thread_loop_->PostTask(
         FROM_HERE, base::Bind(&FakeWindow::DrawFunctorOnRT,
                               base::Unretained(this), &completion));
     completion.Wait();
   }
+
+  if (will_wait_for_mode_draw_to_finish_)
+    on_draw_hardware_pending_ = false;
 }
 
 void FakeWindow::DrawFunctorOnRT(base::WaitableEvent* sync) {
   CheckCurrentlyOnRT();
   // Ok to access UI functions until sync is signalled.
   gfx::Rect location = location_;
   {
     AwDrawGLInfo process_info;
     process_info.version = kAwDrawGLInfoVersion;
     process_info.mode = AwDrawGLInfo::kModeSync;
 
     hooks_->WillSyncOnRT(functor_);
     functor_->DrawGL(&process_info);
     hooks_->DidSyncOnRT(functor_);
   }
-  sync->Signal();
+
+  if (!will_wait_for_mode_draw_to_finish_) {
+    sync->Signal();
+  }
 
   AwDrawGLInfo draw_info;
   draw_info.version = kAwDrawGLInfoVersion;
   draw_info.mode = AwDrawGLInfo::kModeDraw;
   draw_info.clip_left = location.x();
   draw_info.clip_top = location.y();
   draw_info.clip_right = location.x() + location.width();
   draw_info.clip_bottom = location.y() + location.height();
-  draw_info.width = surface_size_.width();
-  draw_info.height = surface_size_.height();
-  draw_info.is_layer = false;
 
-  draw_info.transform[0] = 1.0;
-  draw_info.transform[1] = 0.0;
-  draw_info.transform[2] = 0.0;
-  draw_info.transform[3] = 0.0;
+  hooks_->SetParentDrawConstraints(draw_info);
 
-  draw_info.transform[4] = 0.0;
-  draw_info.transform[5] = 1.0;
-  draw_info.transform[6] = 0.0;
-  draw_info.transform[7] = 0.0;
+  if (!hooks_->WillDrawOnRT(functor_)) {
+    if (will_wait_for_mode_draw_to_finish_) {
+      sync->Signal();
+    }
+    return;
+  }
 
-  draw_info.transform[8] = 0.0;
-  draw_info.transform[9] = 0.0;
-  draw_info.transform[10] = 1.0;
-  draw_info.transform[11] = 0.0;
-
-  draw_info.transform[12] = 0.0;
-  draw_info.transform[13] = 0.0;
-  draw_info.transform[14] = 0.0;
-  draw_info.transform[15] = 1.0;
-
-  hooks_->WillDrawOnRT(functor_);
   {
     ScopedMakeCurrent make_current(this);
     functor_->DrawGL(&draw_info);
   }
   hooks_->DidDrawOnRT(functor_);
+  if (will_wait_for_mode_draw_to_finish_) {
+    sync->Signal();
+  }
 }
 
 void FakeWindow::CheckCurrentlyOnUIThread() {
   DCHECK(ui_checker_.CalledOnValidSequencedThread());
 }
 
 void FakeWindow::CreateRenderThreadIfNeeded() {
   CheckCurrentlyOnUIThread();
   if (functor_) {
     DCHECK(render_thread_.get());
@@ skipping 32 matching lines @@
     surface_ = nullptr;
   }
   sync->Signal();
 }
 
 void FakeWindow::CheckCurrentlyOnRT() {
   DCHECK(rt_checker_.CalledOnValidSequencedThread());
 }
 
 }  // namespace android_webview