Remove NULL ResourceProvider, TileManager early outs

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/json/json_writer.h"
@@ skipping 731 matching lines @@
                             active_tree_->background_color(),
                             occlusion_tracker);
   }
 
   if (draw_frame)
     occlusion_tracker.overdraw_metrics()->RecordMetrics(this);
   else
     DCHECK(!have_copy_request);
 
   RemoveRenderPasses(CullRenderPassesWithNoQuads(), frame);
   if (!output_surface_->ForcedDrawToSoftwareDevice())

[danakj, 2013/06/20 18:00:33]

Should this go away (in another CL)?

[boliu, 2013/06/20 21:01:43]

I think so after the WillDraw change that skips drawing most layers in software
mode.

One bit of concern is that if this is a software draw after hardware has been
initialized, we might be freeing textures here. However we are already doing
this all over the place anyway and one more won't hurt for now. Planned fix is
to queue up commands and pump commands only in a hardware draw or this other
"process mode" callback that webview can request at any time. In this process
mode callback, the context current, but we are not allowed to draw.

     renderer_->DecideRenderPassAllocationsForFrame(frame->render_passes);
-  if (renderer_) {

[boliu, 2013/06/20 17:13:53]

I'm not sure why this was added. Renderer was always created.

-    RemoveRenderPasses(CullRenderPassesWithCachedTextures(renderer_.get()),
-                       frame);
-  }
+  RemoveRenderPasses(CullRenderPassesWithCachedTextures(renderer_.get()),
+                     frame);
 
   // If we're making a frame to draw, it better have at least one render pass.
   DCHECK(!frame->render_passes.empty());
   return draw_frame;
 }
 
 void LayerTreeHostImpl::MainThreadHasStoppedFlinging() {
   if (input_handler_client_)
     input_handler_client_->MainThreadHasStoppedFlinging();
 }
@@ skipping 443 matching lines @@
   }
   active_tree_->root_layer()->ResetAllChangeTrackingForSubtree();
 }
 
 void LayerTreeHostImpl::DidDrawAllLayers(const FrameData& frame) {
   for (size_t i = 0; i < frame.will_draw_layers.size(); ++i)
     frame.will_draw_layers[i]->DidDraw(resource_provider_.get());
 
   // Once all layers have been drawn, pending texture uploads should no
   // longer block future uploads.
-  if (resource_provider_)
-    resource_provider_->MarkPendingUploadsAsNonBlocking();
+  resource_provider_->MarkPendingUploadsAsNonBlocking();
 }
 
 void LayerTreeHostImpl::FinishAllRendering() {
   if (renderer_)
     renderer_->Finish();
 }
 
 bool LayerTreeHostImpl::IsContextLost() {
   DCHECK(proxy_->IsImplThread());
   return renderer_ && renderer_->IsContextLost();
@@ skipping 1130 matching lines @@
 }
 
 void LayerTreeHostImpl::SetDebugState(const LayerTreeDebugState& debug_state) {
   if (debug_state_.continuous_painting != debug_state.continuous_painting)
     paint_time_counter_->ClearHistory();
 
   debug_state_ = debug_state;
 }
 
 }  // namespace cc