Explicitly specify the ui::Compositor to DelegatedFrameHost

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/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
@@ skipping 61 matching lines @@
 void DelegatedFrameHostClient::RequestCopyOfOutput(
     scoped_ptr<cc::CopyOutputRequest> request) {
   GetDelegatedFrameHost()->RequestCopyOfOutput(request.Pass());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost
 
 DelegatedFrameHost::DelegatedFrameHost(DelegatedFrameHostClient* client)
     : client_(client),
+      compositor_(nullptr),
       use_surfaces_(UseSurfacesEnabled()),
       last_output_surface_id_(0),
       pending_delegated_ack_count_(0),
       skipped_frames_(false),
       current_scale_factor_(1.f),
       can_lock_compositor_(YES_CAN_LOCK),
       delegated_frame_evictor_(new DelegatedFrameEvictor(this)) {
   ImageTransportFactory::GetInstance()->AddObserver(this);
 }
 
 void DelegatedFrameHost::WasShown(const ui::LatencyInfo& latency_info) {
   delegated_frame_evictor_->SetVisible(true);
 
   if (surface_id_.is_null() && !frame_provider_.get() &&
       !released_front_lock_.get()) {
-    ui::Compositor* compositor = client_->GetCompositor();
-    if (compositor)
-      released_front_lock_ = compositor->GetCompositorLock();
+    if (compositor_)
+      released_front_lock_ = compositor_->GetCompositorLock();
   }
 
-  ui::Compositor* compositor = client_->GetCompositor();
-  if (compositor) {
-    compositor->SetLatencyInfo(latency_info);
+  if (compositor_) {
+    compositor_->SetLatencyInfo(latency_info);
   }
 }
 
 bool DelegatedFrameHost::HasSavedFrame() {
   return delegated_frame_evictor_->HasFrame();
 }
 
 void DelegatedFrameHost::WasHidden() {
   delegated_frame_evictor_->SetVisible(false);
   released_front_lock_ = NULL;
 }
 
 void DelegatedFrameHost::MaybeCreateResizeLock() {
   if (!client_->ShouldCreateResizeLock())
     return;
-  DCHECK(client_->GetCompositor());
-
-  // Listen to changes in the compositor lock state.
-  ui::Compositor* compositor = client_->GetCompositor();
-  if (!compositor->HasObserver(this))
-    compositor->AddObserver(this);
+  DCHECK(compositor_);
 
   bool defer_compositor_lock =
       can_lock_compositor_ == NO_PENDING_RENDERER_FRAME ||
       can_lock_compositor_ == NO_PENDING_COMMIT;
 
   if (can_lock_compositor_ == YES_CAN_LOCK)
     can_lock_compositor_ = YES_DID_LOCK;
 
   resize_lock_ = client_->CreateResizeLock(defer_compositor_lock);
 }
 
 bool DelegatedFrameHost::ShouldCreateResizeLock() {
   RenderWidgetHostImpl* host = client_->GetHost();
 
   if (resize_lock_)
     return false;
 
   if (host->auto_resize_enabled())
     return false;
 
   gfx::Size desired_size = client_->DesiredFrameSize();
   if (desired_size == current_frame_size_in_dip_ || desired_size.IsEmpty())
     return false;
 
-  ui::Compositor* compositor = client_->GetCompositor();
-  if (!compositor)
+  if (!compositor_)
     return false;
 
   return true;
 }
 
 void DelegatedFrameHost::RequestCopyOfOutput(
     scoped_ptr<cc::CopyOutputRequest> request) {
   client_->GetLayer()->RequestCopyOfOutput(request.Pass());
 }
 
@@ skipping 56 matching lines @@
   if (subscriber_texture.get()) {
     request->SetTextureMailbox(
         cc::TextureMailbox(subscriber_texture->mailbox(),
                            subscriber_texture->target(),
                            subscriber_texture->sync_point()));
   }
   client_->RequestCopyOfOutput(request.Pass());
 }
 
 bool DelegatedFrameHost::CanCopyToBitmap() const {
-  return client_->GetCompositor() &&
-         client_->GetLayer()->has_external_content();
+  return compositor_ && client_->GetLayer()->has_external_content();
 }
 
 bool DelegatedFrameHost::CanCopyToVideoFrame() const {
-  return client_->GetCompositor() &&
-         client_->GetLayer()->has_external_content();
+  return compositor_ && client_->GetLayer()->has_external_content();
 }
 
 bool DelegatedFrameHost::CanSubscribeFrame() const {
   return true;
 }
 
 void DelegatedFrameHost::BeginFrameSubscription(
     scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) {
   frame_subscriber_ = subscriber.Pass();
 }
@@ skipping 31 matching lines @@
 
 void DelegatedFrameHost::CheckResizeLock() {
   if (!resize_lock_ ||
       resize_lock_->expected_size() != current_frame_size_in_dip_)
     return;
 
   // Since we got the size we were looking for, unlock the compositor. But delay
   // the release of the lock until we've kicked a frame with the new texture, to
   // avoid resizing the UI before we have a chance to draw a "good" frame.
   resize_lock_->UnlockCompositor();
-  ui::Compositor* compositor = client_->GetCompositor();
-  if (compositor) {
-    if (!compositor->HasObserver(this))
-      compositor->AddObserver(this);
-  }
 }
 
 void DelegatedFrameHost::DidReceiveFrameFromRenderer(
     const gfx::Rect& damage_rect) {
   if (!frame_subscriber() || !CanCopyToVideoFrame())
     return;
 
   const base::TimeTicks now = gfx::FrameTime::Now();
   base::TimeTicks present_time;
   if (vsync_timebase_.is_null() || vsync_interval_ <= base::TimeDelta()) {
@@ skipping 77 matching lines @@
     if (resource_collection_.get()) {
       resource_collection_->SetClient(NULL);
 
       if (resource_collection_->LoseAllResources())
         SendReturnedDelegatedResources(last_output_surface_id_);
 
       resource_collection_ = NULL;
     }
     last_output_surface_id_ = output_surface_id;
   }
-  ui::Compositor* compositor = client_->GetCompositor();
-  bool immediate_ack = !compositor;
+  bool immediate_ack = !compositor_;
   if (frame_size.IsEmpty()) {
     DCHECK(frame_data->resource_list.empty());
     EvictDelegatedFrame();
   } else {
     if (use_surfaces_) {
       ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
       cc::SurfaceManager* manager = factory->GetSurfaceManager();
       if (!surface_factory_) {
         id_allocator_ =
             factory->GetContextFactory()->CreateSurfaceIdAllocator();
@@ skipping 23 matching lines @@
       compositor_frame->metadata.latency_info.insert(
           compositor_frame->metadata.latency_info.end(),
           latency_info.begin(),
           latency_info.end());
 
       gfx::Size desired_size = client_->DesiredFrameSize();
       if (desired_size != frame_size_in_dip && !desired_size.IsEmpty())
         immediate_ack = true;
 
       cc::SurfaceFactory::DrawCallback ack_callback;
-      if (compositor && !immediate_ack) {
+      if (compositor_ && !immediate_ack) {
         ack_callback = base::Bind(&DelegatedFrameHost::SurfaceDrawn,
                                   AsWeakPtr(), output_surface_id);
       }
       surface_factory_->SubmitFrame(
           surface_id_, compositor_frame.Pass(), ack_callback);
     } else {
       if (!resource_collection_.get()) {
         resource_collection_ = new cc::DelegatedFrameResourceCollection;
         resource_collection_->SetClient(this);
       }
@@ skipping 21 matching lines @@
   if (!damage_rect_in_dip.IsEmpty())
     client_->GetLayer()->OnDelegatedFrameDamage(damage_rect_in_dip);
 
   pending_delegated_ack_count_++;
 
   if (immediate_ack) {
     SendDelegatedFrameAck(output_surface_id);
   } else if (!use_surfaces_) {
     std::vector<ui::LatencyInfo>::const_iterator it;
     for (it = latency_info.begin(); it != latency_info.end(); ++it)
-      compositor->SetLatencyInfo(*it);
+      compositor_->SetLatencyInfo(*it);
     // If we've previously skipped any latency infos add them.
     for (it = skipped_latency_info_list_.begin();
         it != skipped_latency_info_list_.end();
         ++it)
-      compositor->SetLatencyInfo(*it);
+      compositor_->SetLatencyInfo(*it);
     skipped_latency_info_list_.clear();
     AddOnCommitCallbackAndDisableLocks(
         base::Bind(&DelegatedFrameHost::SendDelegatedFrameAck,
                    AsWeakPtr(),
                    output_surface_id));
   } else {
     AddOnCommitCallbackAndDisableLocks(base::Closure());
   }
   DidReceiveFrameFromRenderer(damage_rect);
   if (frame_provider_.get() || !surface_id_.is_null())
@@ skipping 426 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::OnCompositingShuttingDown(ui::Compositor* compositor) {
+  DCHECK_EQ(compositor, compositor_);
+  ResetCompositor();
+  DCHECK(!compositor_);
+}
+
 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() {
+  DCHECK(!compositor_);
   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_.get());
 }
 
 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);
+  DCHECK(compositor_);
 
   can_lock_compositor_ = NO_PENDING_COMMIT;
   if (!callback.is_null())
     on_compositing_did_commit_callbacks_.push_back(callback);
 }
 
-void DelegatedFrameHost::AddedToWindow() {
-  ui::Compositor* compositor = client_->GetCompositor();
-  if (compositor) {
-    DCHECK(!vsync_manager_.get());
-    vsync_manager_ = compositor->vsync_manager();
-    vsync_manager_->AddObserver(this);
-  }
+void DelegatedFrameHost::SetCompositor(ui::Compositor* compositor) {
+  DCHECK(!compositor_);
+  if (!compositor)
+    return;
+  compositor_ = compositor;
+  compositor_->AddObserver(this);
+  DCHECK(!vsync_manager_.get());
+  vsync_manager_ = compositor_->vsync_manager();
+  vsync_manager_->AddObserver(this);
 }
 
-void DelegatedFrameHost::RemovingFromWindow() {
+void DelegatedFrameHost::ResetCompositor() {
+  if (!compositor_)
+    return;
   RunOnCommitCallbacks();
   resize_lock_.reset();
   client_->GetHost()->WasResized();
-  ui::Compositor* compositor = client_->GetCompositor();
-  if (compositor && compositor->HasObserver(this))
-    compositor->RemoveObserver(this);
-
+  if (compositor_->HasObserver(this))
+    compositor_->RemoveObserver(this);
   if (vsync_manager_.get()) {
     vsync_manager_->RemoveObserver(this);
     vsync_manager_ = NULL;
   }
+  compositor_ = nullptr;
 }
 
 void DelegatedFrameHost::LockResources() {
   DCHECK(frame_provider_.get() || !surface_id_.is_null());
   delegated_frame_evictor_->LockFrame();
 }
 
 void DelegatedFrameHost::UnlockResources() {
   DCHECK(frame_provider_.get() || !surface_id_.is_null());
   delegated_frame_evictor_->UnlockFrame();
@@ skipping 16 matching lines @@
     cc::SurfaceManager* manager = factory->GetSurfaceManager();
     new_layer->SetShowSurface(
         surface_id_, base::Bind(&SatisfyCallback, base::Unretained(manager)),
         base::Bind(&RequireCallback, base::Unretained(manager)),
         current_surface_size_, current_scale_factor_,
         current_frame_size_in_dip_);
   }
 }
 
 }  // namespace content