cc: Add BeginFrameArgs

content/browser/android/content_view_core_impl.cc

 // Copyright (c) 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 "content/browser/android/content_view_core_impl.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "cc/layers/layer.h"
+#include "cc/output/begin_frame_args.h"
 #include "content/browser/android/interstitial_page_delegate_android.h"
 #include "content/browser/android/load_url_params.h"
 #include "content/browser/android/media_player_manager_impl.h"
 #include "content/browser/android/touch_point.h"
 #include "content/browser/renderer_host/compositor_impl_android.h"
 #include "content/browser/renderer_host/java/java_bound_object.h"
 #include "content/browser/renderer_host/java/java_bridge_dispatcher_host_manager.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_android.h"
@@ skipping 43 matching lines @@
 enum PopupItemType {
   POPUP_ITEM_TYPE_GROUP = 0,
   POPUP_ITEM_TYPE_DISABLED,
   POPUP_ITEM_TYPE_ENABLED
 };
 
 namespace content {
 
 namespace {
 
+const unsigned int kDefaultVSyncIntervalMicros = 16666u;
+// TODO(brianderson): Use adaptive draw-time estimation.
+const float kDefaultBrowserCompositeVSyncFraction = 1.0f / 3;
+
 const void* kContentViewUserDataKey = &kContentViewUserDataKey;
 
 int GetRenderProcessIdFromRenderViewHost(RenderViewHost* host) {
   DCHECK(host);
   RenderProcessHost* render_process = host->GetProcess();
   DCHECK(render_process);
   if (render_process->HasConnection())
     return render_process->GetHandle();
   else
     return 0;
@@ skipping 61 matching lines @@
 
 ContentViewCoreImpl::ContentViewCoreImpl(JNIEnv* env, jobject obj,
                                          bool hardware_accelerated,
                                          WebContents* web_contents,
                                          ui::ViewAndroid* view_android,
                                          ui::WindowAndroid* window_android)
     : java_ref_(env, obj),
       web_contents_(static_cast<WebContentsImpl*>(web_contents)),
       root_layer_(cc::Layer::Create()),
       tab_crashed_(false),
+      vsync_interval_(base::TimeDelta::FromMicroseconds(
+          kDefaultVSyncIntervalMicros)),
+      expected_browser_composite_time_(base::TimeDelta::FromMicroseconds(
+          kDefaultVSyncIntervalMicros * kDefaultBrowserCompositeVSyncFraction)),
       view_android_(view_android),
       window_android_(window_android) {
   CHECK(web_contents) <<
       "A ContentViewCoreImpl should be created with a valid WebContents.";
 
   // When a tab is restored (from a saved state), it does not have a renderer
   // process.  We treat it like the tab is crashed. If the content is loaded
   // when the tab is shown, tab_crashed_ will be reset.  Since
   // RenderWidgetHostView is associated with the lifetime of the renderer
   // process, we use it to test whether there is a renderer process.
@@ skipping 523 matching lines @@
 void ContentViewCoreImpl::RemoveLayer(scoped_refptr<cc::Layer> layer) {
   layer->RemoveFromParent();
 }
 
 void ContentViewCoreImpl::LoadUrl(
     NavigationController::LoadURLParams& params) {
   GetWebContents()->GetController().LoadURLWithParams(params);
   tab_crashed_ = false;
 }
 
-void ContentViewCoreImpl::SetVSyncNotificationEnabled(bool enabled) {
+void ContentViewCoreImpl::SetNeedsBeginFrame(bool enabled) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
   Java_ContentViewCore_setVSyncNotificationEnabled(
       env, obj.obj(), static_cast<jboolean>(enabled));
 }
 
 void ContentViewCoreImpl::SetNeedsAnimate() {
   JNIEnv* env = AttachCurrentThread();
@@ skipping 501 matching lines @@
   RenderWidgetHostViewAndroid* view = GetRenderWidgetHostViewAndroid();
   if (!view)
     return;
 
   RenderWidgetHostImpl* host = RenderWidgetHostImpl::From(
       view->GetRenderWidgetHost());
 
   host->UpdateVSyncParameters(
       base::TimeTicks::FromInternalValue(timebase_micros),
       base::TimeDelta::FromMicroseconds(interval_micros));
+

[no sievers, 2013/06/13 01:17:47]

Is this function still getting called with begin frame notifications enabled?

[Sami, 2013/06/13 10:01:07]

Yes, we call when attaching the view for the first time to establish the vsync
timebase and interval.

[brianderson, 2013/06/14 20:12:02]

It is also called now when we did not draw after a BeginFrame and we want a
newer BeginFrame.

+  vsync_interval_ =
+      base::TimeDelta::FromMicroseconds(interval_micros);
+  expected_browser_composite_time_ =
+      vsync_interval_ * kDefaultBrowserCompositeVSyncFraction;
 }
 
 void ContentViewCoreImpl::OnVSync(JNIEnv* env, jobject /* obj */,
                                   jlong frame_time_micros) {
   RenderWidgetHostViewAndroid* view = GetRenderWidgetHostViewAndroid();
   if (!view)
     return;
 
+  base::TimeTicks frame_time =
+      base::TimeTicks::FromInternalValue(frame_time_micros);
+  base::TimeTicks display_time = frame_time + vsync_interval_;
+  base::TimeTicks deadline = display_time - expected_browser_composite_time_;
+
   view->SendBeginFrame(
-      base::TimeTicks::FromInternalValue(frame_time_micros));
+      cc::BeginFrameArgs::CreateBeginFrame(
+          frame_time, deadline, vsync_interval_));
 }
 
 jboolean ContentViewCoreImpl::OnAnimate(JNIEnv* env, jobject /* obj */,
                                         jlong frame_time_micros) {
   RenderWidgetHostViewAndroid* view = GetRenderWidgetHostViewAndroid();
   if (!view)
     return false;
 
   return view->Animate(base::TimeTicks::FromInternalValue(frame_time_micros));
 }
@@ skipping 310 matching lines @@
       reinterpret_cast<ui::ViewAndroid*>(view_android),
       reinterpret_cast<ui::WindowAndroid*>(window_android));
   return reinterpret_cast<jint>(view);
 }
 
 bool RegisterContentViewCore(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace content