Revert of Fix NTP thumbnail generation

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 "base/time/default_tick_clock.h"
 #include "cc/output/compositor_frame.h"
@@ skipping 358 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;
   }
-  bool skip_frame_size_mismatch = false;
+  bool immediate_ack = !compositor_;
   pending_delegated_ack_count_++;
 
   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_) {
@@ skipping 21 matching lines @@
 
       compositor_frame->metadata.latency_info.swap(skipped_latency_info_list_);
       compositor_frame->metadata.latency_info.insert(
           compositor_frame->metadata.latency_info.end(),
           latency_info.begin(),
           latency_info.end());
       compositor_frame->metadata.satisfies_sequences.swap(*satisfies_sequences);
 
       gfx::Size desired_size = client_->DelegatedFrameHostDesiredSizeInDIP();
       if (desired_size != frame_size_in_dip && !desired_size.IsEmpty())
-        skip_frame_size_mismatch = true;
+        immediate_ack = true;
 
       cc::SurfaceFactory::DrawCallback ack_callback;
-      if (compositor_ && !skip_frame_size_mismatch) {
+      if (compositor_ && !immediate_ack) {
         ack_callback = base::Bind(&DelegatedFrameHost::SurfaceDrawn,
                                   AsWeakPtr(), output_surface_id);
       }
       surface_factory_->SubmitCompositorFrame(
           surface_id_, compositor_frame.Pass(), ack_callback);
     } else {
       if (!resource_collection_.get()) {
         resource_collection_ = new cc::DelegatedFrameResourceCollection;
         resource_collection_->SetClient(this);
       }
@@ skipping 15 matching lines @@
     }
   }
   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);
 
-  // Note that |compositor_| may be reset by SetShowSurface or
-  // SetShowDelegatedContent above.
-  if (!compositor_ || skip_frame_size_mismatch) {
+  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);
     // 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);
@@ skipping 573 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