Unified BeginFrame scheduling

content/browser/compositor/delegated_frame_host.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 "content/browser/compositor/delegated_frame_host.h"
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
+#include "cc/output/begin_frame_args.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/resources/texture_mailbox.h"
 #include "cc/surfaces/surface_factory.h"
 #include "content/browser/compositor/resize_lock.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/public/browser/render_widget_host_view_frame_subscriber.h"
 #include "content/public/common/content_switches.h"
@@ skipping 736 matching lines @@
       dfh->AsWeakPtr(),
       callback,
       subscriber_texture,
       base::Passed(&release_callback));
   yuv_readback_pipeline->ReadbackYUV(texture_mailbox.mailbox(),
                                      texture_mailbox.sync_point(),
                                      video_frame.get(),
                                      finished_callback);
 }
 
+void DelegatedFrameHost::UpdateVSyncParameters(const cc::BeginFrameArgs& args) {
+  vsync_timebase_ = args.frame_time;
+  vsync_interval_ = args.interval;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, ui::CompositorObserver implementation:
 
 void DelegatedFrameHost::OnCompositingDidCommit(
     ui::Compositor* compositor) {
   RenderWidgetHostImpl* host = client_->GetHost();
   if (can_lock_compositor_ == NO_PENDING_COMMIT) {
     can_lock_compositor_ = YES_CAN_LOCK;
     if (resize_lock_.get() && resize_lock_->GrabDeferredLock())
       can_lock_compositor_ = YES_DID_LOCK;
@@ skipping 24 matching lines @@
 
 void DelegatedFrameHost::OnCompositingLockStateChanged(
     ui::Compositor* compositor) {
   // A compositor lock that is part of a resize lock timed out. We
   // should display a renderer frame.
   if (!compositor->IsLocked() && can_lock_compositor_ == YES_DID_LOCK) {
     can_lock_compositor_ = NO_PENDING_RENDERER_FRAME;
   }
 }
 
-void DelegatedFrameHost::OnUpdateVSyncParameters(
-    base::TimeTicks timebase,
-    base::TimeDelta interval) {
-  vsync_timebase_ = timebase;
-  vsync_interval_ = interval;
-  RenderWidgetHostImpl* host = client_->GetHost();
-  if (client_->IsVisible())
-    host->UpdateVSyncParameters(timebase, interval);
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, ImageTransportFactoryObserver implementation:
 
 void DelegatedFrameHost::OnLostResources() {
   RenderWidgetHostImpl* host = client_->GetHost();
   if (frame_provider_.get() || !surface_id_.is_null())
     EvictDelegatedFrame();
   idle_frame_subscriber_textures_.clear();
   yuv_readback_pipeline_.reset();
 
   host->ScheduleComposite();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, private:
 
 DelegatedFrameHost::~DelegatedFrameHost() {
   ImageTransportFactory::GetInstance()->RemoveObserver(this);
 
   if (!surface_id_.is_null())
     surface_factory_->Destroy(surface_id_);
   if (resource_collection_.get())
     resource_collection_->SetClient(NULL);
-
-  DCHECK(!vsync_manager_);
 }
 
 void DelegatedFrameHost::RunOnCommitCallbacks() {
   for (std::vector<base::Closure>::const_iterator
       it = on_compositing_did_commit_callbacks_.begin();
       it != on_compositing_did_commit_callbacks_.end(); ++it) {
     it->Run();
   }
   on_compositing_did_commit_callbacks_.clear();
 }
 
 void DelegatedFrameHost::AddOnCommitCallbackAndDisableLocks(
     const base::Closure& callback) {
   ui::Compositor* compositor = client_->GetCompositor();
   DCHECK(compositor);
 
   if (!compositor->HasObserver(this))
     compositor->AddObserver(this);
 
   can_lock_compositor_ = NO_PENDING_COMMIT;
   on_compositing_did_commit_callbacks_.push_back(callback);
 }
 
 void DelegatedFrameHost::AddedToWindow() {
-  ui::Compositor* compositor = client_->GetCompositor();
-  if (compositor) {
-    DCHECK(!vsync_manager_);
-    vsync_manager_ = compositor->vsync_manager();
-    vsync_manager_->AddObserver(this);
-  }
 }
 
 void DelegatedFrameHost::RemovingFromWindow() {
   RunOnCommitCallbacks();
   resize_lock_.reset();
   client_->GetHost()->WasResized();
   ui::Compositor* compositor = client_->GetCompositor();
   if (compositor && compositor->HasObserver(this))
     compositor->RemoveObserver(this);
-
-  if (vsync_manager_) {
-    vsync_manager_->RemoveObserver(this);
-    vsync_manager_ = NULL;
-  }
 }
 
 void DelegatedFrameHost::LockResources() {
   DCHECK(frame_provider_ || !surface_id_.is_null());
   delegated_frame_evictor_->LockFrame();
 }
 
 void DelegatedFrameHost::UnlockResources() {
   DCHECK(frame_provider_ || !surface_id_.is_null());
   delegated_frame_evictor_->UnlockFrame();
@@ skipping 10 matching lines @@
   if (frame_provider_.get()) {
     new_layer->SetShowDelegatedContent(frame_provider_.get(),
                                        current_frame_size_in_dip_);
   }
   if (!surface_id_.is_null()) {
     new_layer->SetShowSurface(surface_id_, current_frame_size_in_dip_);
   }
 }
 
 }  // namespace content