Remove browser-side tracking of accelerated compositing

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 28 matching lines @@
     : client_(client),
       last_output_surface_id_(0),
       pending_delegated_ack_count_(0),
       skipped_frames_(false),
       can_lock_compositor_(YES),
       delegated_frame_evictor_(new DelegatedFrameEvictor(this)) {
   ImageTransportFactory::GetInstance()->AddObserver(this);
 }
 
 void DelegatedFrameHost::WasShown() {
-  RenderWidgetHostImpl* host = client_->GetHost();
   delegated_frame_evictor_->SetVisible(true);
 
-  if (host->is_accelerated_compositing_active() &&
-      !released_front_lock_.get()) {
+  if (!released_front_lock_.get()) {
     ui::Compositor* compositor = client_->GetCompositor();
     if (compositor)
       released_front_lock_ = compositor->GetCompositorLock();
   }
 }
 
 void DelegatedFrameHost::WasHidden() {
   delegated_frame_evictor_->SetVisible(false);
   released_front_lock_ = NULL;
 }
@@ skipping 29 matching lines @@
   // resizing we compensate by blocking the UI thread in Compositor::Draw() by
   // issuing a FinishAllRendering() if we are resizing.
 #if defined(OS_WIN)
   return false;
 #else
   if (resize_lock_)
     return false;
 
   if (host->should_auto_resize())
     return false;
-  if (!host->is_accelerated_compositing_active())

[danakj, 2014/05/12 17:37:58]

Does this mean if you tried to resize during a slow page load, you'd resize lock
until the new site loaded while we're showing blank? Or are there any
implications to this wrt page load that we need to consider?

[piman, 2014/05/13 20:25:40]

It is actually a desirable outcome. The resize lock is on a (short) timeout. If
the page finishes loading during that time, and is able to produce a frame of
the right size, we'd want to give it a chance.

-    return false;
 
   gfx::Size desired_size = client_->DesiredFrameSize();
   if (desired_size == current_frame_size_in_dip_)
     return false;
 
   ui::Compositor* compositor = client_->GetCompositor();
   if (!compositor)
     return false;
 
   return true;
@@ skipping 87 matching lines @@
   }
   client_->RequestCopyOfOutput(request.Pass());
 }
 
 bool DelegatedFrameHost::CanCopyToBitmap() const {
   return client_->GetCompositor() &&
          client_->GetLayer()->has_external_content();
 }
 
 bool DelegatedFrameHost::CanCopyToVideoFrame() const {
-  RenderWidgetHostImpl* host = client_->GetHost();
   return client_->GetCompositor() &&
-         client_->GetLayer()->has_external_content() &&
-         host->is_accelerated_compositing_active();
+         client_->GetLayer()->has_external_content();
 }
 
 bool DelegatedFrameHost::CanSubscribeFrame() const {
   return true;
 }
 
 void DelegatedFrameHost::BeginFrameSubscription(
     scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) {
   frame_subscriber_ = subscriber.Pass();
 }
@@ skipping 641 matching lines @@
   // that should keep our frame. old_layer will be returned to the
   // RecreateLayer caller, and should have a copy.
   if (frame_provider_.get()) {
     new_layer->SetShowDelegatedContent(frame_provider_.get(),
                                        current_frame_size_in_dip_);
   }
 }
 
 }  // namespace content