cc: Change CallFunctionForSubtree to use lambdas.

cc/trees/layer_tree_host.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.h"
 
 #include <algorithm>
 #include <stack>
 #include <string>
 
@@ skipping 194 matching lines @@
     // made a contract with our animation controllers that the registrar
     // will outlive them, and we must make good.
     root_layer_ = NULL;
   }
 }
 
 void LayerTreeHost::SetLayerTreeHostClientReady() {
   proxy_->SetLayerTreeHostClientReady();
 }
 
-static void LayerTreeHostOnOutputSurfaceCreatedCallback(Layer* layer) {
-  layer->OnOutputSurfaceCreated();
-}
-
 void LayerTreeHost::DeleteContentsTexturesOnImplThread(
     ResourceProvider* resource_provider) {
   DCHECK(proxy_->IsImplThread());
   if (contents_texture_manager_)
     contents_texture_manager_->ClearAllMemory(resource_provider);
 }
 
 void LayerTreeHost::WillBeginMainFrame() {
   devtools_instrumentation::WillBeginMainThreadFrame(id(),
                                                      source_frame_number());
@@ skipping 188 matching lines @@
 
   if (!contents_texture_manager_ && !settings_.impl_side_painting) {
     contents_texture_manager_ =
         PrioritizedResourceManager::Create(proxy_.get());
     surface_memory_placeholder_ =
         contents_texture_manager_->CreateTexture(gfx::Size(), RGBA_8888);
   }
 
   if (root_layer()) {
     LayerTreeHostCommon::CallFunctionForSubtree(
-        root_layer(), base::Bind(&LayerTreeHostOnOutputSurfaceCreatedCallback));
+        root_layer(), [](Layer* layer) { layer->OnOutputSurfaceCreated(); });
   }
 
   client_->DidInitializeOutputSurface();
 }
 
 void LayerTreeHost::DidFailToInitializeOutputSurface() {
   DCHECK(output_surface_lost_);
   client_->DidFailToInitializeOutputSurface();
 }
 
@@ skipping 421 matching lines @@
         can_render_to_separate_surface,
         settings_.layer_transforms_should_scale_layer_contents,
         settings_.verify_property_trees, &update_list,
         render_surface_layer_list_id);
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     if (total_frames_used_for_lcd_text_metrics_ <=
         kTotalFramesToUseForLCDTextMetrics) {
       LayerTreeHostCommon::CallFunctionForSubtree(
           root_layer,
-          base::Bind(&LayerTreeHost::CalculateLCDTextMetricsCallback,
-                     base::Unretained(this)));
+          [this](Layer* layer) { CalculateLCDTextMetricsCallback(layer); });
       total_frames_used_for_lcd_text_metrics_++;
     }
 
     if (total_frames_used_for_lcd_text_metrics_ ==
         kTotalFramesToUseForLCDTextMetrics) {
       total_frames_used_for_lcd_text_metrics_++;
 
       UMA_HISTOGRAM_PERCENTAGE(
           "Renderer4.LCDText.PercentageOfCandidateLayers",
           lcd_text_metrics_.total_num_cc_layers_can_use_lcd_text * 100.0 /
@@ skipping 24 matching lines @@
 
   return did_paint_content;
 }
 
 void LayerTreeHost::TriggerPrepaint() {
   prepaint_callback_.Cancel();
   TRACE_EVENT0("cc", "LayerTreeHost::TriggerPrepaint");
   SetNeedsCommit();
 }
 
-static void LayerTreeHostReduceMemoryCallback(Layer* layer) {
-  layer->ReduceMemoryUsage();
-}
-
 void LayerTreeHost::ReduceMemoryUsage() {
   if (!root_layer())
     return;
 
   LayerTreeHostCommon::CallFunctionForSubtree(
-      root_layer(),
-      base::Bind(&LayerTreeHostReduceMemoryCallback));
+      root_layer(), [](Layer* layer) { layer->ReduceMemoryUsage(); });
 }
 
 void LayerTreeHost::SetPrioritiesForSurfaces(size_t surface_memory_bytes) {
   DCHECK(surface_memory_placeholder_);
 
   // Surfaces have a place holder for their memory since they are managed
   // independantly but should still be tracked and reduce other memory usage.
   surface_memory_placeholder_->SetTextureManager(
       contents_texture_manager_.get());
   surface_memory_placeholder_->set_request_priority(
@@ skipping 434 matching lines @@
     bool children_need_begin_frames) const {
   proxy_->SetChildrenNeedBeginFrames(children_need_begin_frames);
 }
 
 void LayerTreeHost::SendBeginFramesToChildren(
     const BeginFrameArgs& args) const {
   client_->SendBeginFramesToChildren(args);
 }
 
 }  // namespace cc