[C++11 Allowed Features] Declares a type-safe null pointer converting from NULL to nullptr [part-…

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 151 matching lines @@
 LayerTreeHost::~LayerTreeHost() {
   TRACE_EVENT0("cc", "LayerTreeHost::~LayerTreeHost");
 
   DCHECK(swap_promise_monitor_.empty());
 
   BreakSwapPromises(SwapPromise::COMMIT_FAILS);
 
   overhang_ui_resource_ = nullptr;
 
   if (root_layer_.get())
-    root_layer_->SetLayerTreeHost(NULL);
+    root_layer_->SetLayerTreeHost(nullptr);
 
   if (proxy_) {
     DCHECK(proxy_->IsMainThread());
     proxy_->Stop();
   }
 
   // We must clear any pointers into the layer tree prior to destroying it.
-  RegisterViewportLayers(NULL, NULL, NULL);
+  RegisterViewportLayers(nullptr, nullptr, nullptr);
 
   if (root_layer_.get()) {
     // The layer tree must be destroyed before the layer tree host. We've
     // made a contract with our animation controllers that the registrar
     // will outlive them, and we must make good.
-    root_layer_ = NULL;
+    root_layer_ = nullptr;
   }
 }
 
 void LayerTreeHost::SetLayerTreeHostClientReady() {
   proxy_->SetLayerTreeHostClientReady();
 }
 
 static void LayerTreeHostOnOutputSurfaceCreatedCallback(Layer* layer) {
   layer->OnOutputSurfaceCreated();
 }
@@ skipping 116 matching lines @@
   }
 
   sync_tree->set_needs_full_tree_sync(needs_full_tree_sync_);
   needs_full_tree_sync_ = false;
 
   if (hud_layer_.get()) {
     LayerImpl* hud_impl = LayerTreeHostCommon::FindLayerInSubtree(
         sync_tree->root_layer(), hud_layer_->id());
     sync_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(hud_impl));
   } else {
-    sync_tree->set_hud_layer(NULL);
+    sync_tree->set_hud_layer(nullptr);
   }
 
   sync_tree->set_background_color(background_color_);
   sync_tree->set_has_transparent_background(has_transparent_background_);
 
   if (page_scale_layer_.get() && inner_viewport_scroll_layer_.get()) {
     sync_tree->SetViewportLayersFromIds(page_scale_layer_->id(),
                                         inner_viewport_scroll_layer_->id(),
                                         outer_viewport_scroll_layer_.get()
                                             ? outer_viewport_scroll_layer_->id()
@@ skipping 63 matching lines @@
 
 void LayerTreeHost::UpdateHudLayer() {
   if (debug_state_.ShowHudInfo()) {
     if (!hud_layer_.get())
       hud_layer_ = HeadsUpDisplayLayer::Create();
 
     if (root_layer_.get() && !hud_layer_->parent())
       root_layer_->AddChild(hud_layer_);
   } else if (hud_layer_.get()) {
     hud_layer_->RemoveFromParent();
-    hud_layer_ = NULL;
+    hud_layer_ = nullptr;
   }
 }
 
 void LayerTreeHost::CommitComplete() {
   source_frame_number_++;
   client_->DidCommit();
 }
 
 void LayerTreeHost::SetOutputSurface(scoped_ptr<OutputSurface> surface) {
   proxy_->SetOutputSurface(surface.Pass());
 }
 
 void LayerTreeHost::RequestNewOutputSurface() {
   client_->RequestNewOutputSurface(num_failed_recreate_attempts_ >= 4);
 }
 
 scoped_ptr<LayerTreeHostImpl> LayerTreeHost::CreateLayerTreeHostImpl(
     LayerTreeHostImplClient* client) {
   DCHECK(proxy_->IsImplThread());
   scoped_ptr<LayerTreeHostImpl> host_impl =
       LayerTreeHostImpl::Create(settings_,
                                 client,
                                 proxy_.get(),
                                 rendering_stats_instrumentation_.get(),
                                 shared_bitmap_manager_,
                                 id_);
   host_impl->SetUseGpuRasterization(UseGpuRasterization());
-  shared_bitmap_manager_ = NULL;
+  shared_bitmap_manager_ = nullptr;
   if (settings_.calculate_top_controls_position &&
       host_impl->top_controls_manager()) {
     top_controls_manager_weak_ptr_ =
         host_impl->top_controls_manager()->AsWeakPtr();
   }
   input_handler_weak_ptr_ = host_impl->AsWeakPtr();
   return host_impl.Pass();
 }
 
 void LayerTreeHost::DidLoseOutputSurface() {
@@ skipping 118 matching lines @@
       }
     }
   }
 }
 
 void LayerTreeHost::SetRootLayer(scoped_refptr<Layer> root_layer) {
   if (root_layer_.get() == root_layer.get())
     return;
 
   if (root_layer_.get())
-    root_layer_->SetLayerTreeHost(NULL);
+    root_layer_->SetLayerTreeHost(nullptr);
   root_layer_ = root_layer;
   if (root_layer_.get()) {
     DCHECK(!root_layer_->parent());
     root_layer_->SetLayerTreeHost(this);
   }
 
   if (hud_layer_.get())
     hud_layer_->RemoveFromParent();
 
   // Reset gpu rasterization flag.
@@ skipping 158 matching lines @@
 
   bool result = UpdateLayers(root_layer(), queue);
 
   micro_benchmark_controller_.DidUpdateLayers();
 
   return result || next_commit_forces_redraw_;
 }
 
 static Layer* FindFirstScrollableLayer(Layer* layer) {
   if (!layer)
-    return NULL;
+    return nullptr;
 
   if (layer->scrollable())
     return layer;
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
     Layer* found = FindFirstScrollableLayer(layer->children()[i].get());
     if (found)
       return found;
   }
 
-  return NULL;
+  return nullptr;
 }
 
 void LayerTreeHost::RecordGpuRasterizationHistogram() {
   // Gpu rasterization is only supported when impl-side painting is enabled.
   if (gpu_rasterization_histogram_recorded_ || !settings_.impl_side_painting)
     return;
 
   // Record how widely gpu rasterization is enabled.
   // This number takes device/gpu whitelisting/backlisting into account.
   // Note that we do not consider the forced gpu rasterization mode, which is
@@ skipping 215 matching lines @@
                                                ResourceUpdateQueue* queue,
                                                bool* did_paint_content,
                                                bool* need_more_updates) {
   // Note: Masks and replicas only exist for layers that own render surfaces. If
   // we reach this point in code, we already know that at least something will
   // be drawn into this render surface, so the mask and replica should be
   // painted.
 
   Layer* mask_layer = render_surface_layer->mask_layer();
   if (mask_layer) {
-    *did_paint_content |= mask_layer->Update(queue, NULL);
+    *did_paint_content |= mask_layer->Update(queue, nullptr);
     *need_more_updates |= mask_layer->NeedMoreUpdates();
   }
 
   Layer* replica_mask_layer =
-      render_surface_layer->replica_layer() ?
-      render_surface_layer->replica_layer()->mask_layer() : NULL;
+      render_surface_layer->replica_layer()
+          ? render_surface_layer->replica_layer()->mask_layer()
+          : nullptr;
   if (replica_mask_layer) {
-    *did_paint_content |= replica_mask_layer->Update(queue, NULL);
+    *did_paint_content |= replica_mask_layer->Update(queue, nullptr);
     *need_more_updates |= replica_mask_layer->NeedMoreUpdates();
   }
 }
 
 void LayerTreeHost::PaintLayerContents(
     const RenderSurfaceLayerList& render_surface_layer_list,
     ResourceUpdateQueue* queue,
     bool* did_paint_content,
     bool* need_more_updates) {
   OcclusionTracker<Layer> occlusion_tracker(
@@ skipping 197 matching lines @@
 
   TRACE_EVENT0("cc", "LayerTreeHost::AnimateLayers");
 
   AnimationRegistrar::AnimationControllerMap copy =
       animation_registrar_->active_animation_controllers();
   for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
        iter != copy.end();
        ++iter) {
     (*iter).second->Animate(monotonic_time);
     bool start_ready_animations = true;
-    (*iter).second->UpdateState(start_ready_animations, NULL);
+    (*iter).second->UpdateState(start_ready_animations, nullptr);
   }
 }
 
 UIResourceId LayerTreeHost::CreateUIResource(UIResourceClient* client) {
   DCHECK(client);
 
   UIResourceId next_id = next_ui_resource_id_++;
   DCHECK(ui_resource_client_map_.find(next_id) ==
          ui_resource_client_map_.end());
 
@@ skipping 97 matching lines @@
   swap_promise_list_.push_back(swap_promise.Pass());
 }
 
 void LayerTreeHost::BreakSwapPromises(SwapPromise::DidNotSwapReason reason) {
   for (size_t i = 0; i < swap_promise_list_.size(); i++)
     swap_promise_list_[i]->DidNotSwap(reason);
   swap_promise_list_.clear();
 }
 
 }  // namespace cc