cc: Force commit on the frame after a copy request

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 <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 52 matching lines @@
 // DelegatedFrameHost
 
 DelegatedFrameHost::DelegatedFrameHost(DelegatedFrameHostClient* client)
     : client_(client),
       compositor_(nullptr),
       use_surfaces_(UseSurfacesEnabled()),
       tick_clock_(new base::DefaultTickClock()),
       last_output_surface_id_(0),
       pending_delegated_ack_count_(0),
       skipped_frames_(false),
+      force_commit_for_next_frame_(false),
       current_scale_factor_(1.f),
       can_lock_compositor_(YES_CAN_LOCK),
       delegated_frame_evictor_(new DelegatedFrameEvictor(this)) {
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   factory->AddObserver(this);
   id_allocator_ = factory->GetContextFactory()->CreateSurfaceIdAllocator();
 }
 
 void DelegatedFrameHost::WasShown(const ui::LatencyInfo& latency_info) {
   delegated_frame_evictor_->SetVisible(true);
@@ skipping 259 matching lines @@
 
   gfx::Size frame_size = root_pass->output_rect.size();
   gfx::Size frame_size_in_dip =
       gfx::ConvertSizeToDIP(frame_device_scale_factor, frame_size);
 
   gfx::Rect damage_rect = root_pass->damage_rect;
   damage_rect.Intersect(gfx::Rect(frame_size));
   gfx::Rect damage_rect_in_dip =
       gfx::ConvertRectToDIP(frame_device_scale_factor, damage_rect);
 
+  if (compositor_ && force_commit_for_next_frame_) {
+    force_commit_for_next_frame_ = false;
+    compositor_->ScheduleDraw();
+  }
+
   if (ShouldSkipFrame(frame_size_in_dip)) {
     cc::CompositorFrameAck ack;
     cc::TransferableResource::ReturnResources(frame_data->resource_list,
                                               &ack.resources);
 
     skipped_latency_info_list_.insert(skipped_latency_info_list_.end(),
                                       frame->metadata.latency_info.begin(),
                                       frame->metadata.latency_info.end());
 
     client_->DelegatedFrameHostSendCompositorSwapAck(output_surface_id, ack);
@@ skipping 100 matching lines @@
             resource_collection_.get(), std::move(frame->delegated_frame_data));
         client_->DelegatedFrameHostGetLayer()->SetShowDelegatedContent(
             frame_provider_.get(), frame_size_in_dip);
       } else {
         frame_provider_->SetFrameData(std::move(frame->delegated_frame_data));
       }
     }
   }
   released_front_lock_ = NULL;
   current_frame_size_in_dip_ = frame_size_in_dip;
+
   CheckResizeLock();
 
   if (!damage_rect_in_dip.IsEmpty())
     client_->DelegatedFrameHostGetLayer()->OnDelegatedFrameDamage(
         damage_rect_in_dip);
 
   if (immediate_ack) {
     SendDelegatedFrameAck(output_surface_id);
   } else if (!use_surfaces_) {
     std::vector<ui::LatencyInfo>::const_iterator it;
@@ skipping 544 matching lines @@
   DCHECK(frame_provider_.get() || !surface_id_.is_null());
   delegated_frame_evictor_->LockFrame();
 }
 
 void DelegatedFrameHost::RequestCopyOfOutput(
     scoped_ptr<cc::CopyOutputRequest> request) {
   if (!request_copy_of_output_callback_for_testing_.is_null())
     request_copy_of_output_callback_for_testing_.Run(request.Pass());
   else
     client_->DelegatedFrameHostGetLayer()->RequestCopyOfOutput(request.Pass());
+
+  force_commit_for_next_frame_ = true;

[miu, 2015/12/02 20:32:57]

Idea: Should you also call compositor_->ScheduleDraw() here too?  This might
solve a problem I was mentioning in our meeting, where the compositor can decide
to skip a frame.  It's always kept our "smoothness" performance for tab capture
from being perfect.

[ccameron, 2015/12/02 23:03:22]

That would seem like a separate bug if we're not getting a commit when we
request a copy of the output -- the source of my problem is that that causes a
commit which changes the tree, but there is subsequent commit to un-do that
change. So I'd prefer to keep that to separate changes.

[miu, 2015/12/03 00:23:41]

Acknowledged.

 }
 
 void DelegatedFrameHost::UnlockResources() {
   DCHECK(frame_provider_.get() || !surface_id_.is_null());
   delegated_frame_evictor_->UnlockFrame();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, ui::LayerOwnerDelegate implementation:
 
@@ skipping 11 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