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

cc/trees/layer_tree_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_impl.h"
 
 #include <limits>
 #include <set>
 
 #include "base/debug/trace_event.h"
@@ skipping 56 matching lines @@
   LayerImpl* layer_;
   LayerScrollOffsetDelegate* delegate_;
   LayerTreeImpl* layer_tree_impl_;
   gfx::ScrollOffset last_set_scroll_offset_;
 };
 
 LayerTreeImpl::LayerTreeImpl(LayerTreeHostImpl* layer_tree_host_impl)
     : layer_tree_host_impl_(layer_tree_host_impl),
       source_frame_number_(-1),
       hud_layer_(0),
-      currently_scrolling_layer_(NULL),
-      root_layer_scroll_offset_delegate_(NULL),
+      currently_scrolling_layer_(nullptr),
+      root_layer_scroll_offset_delegate_(nullptr),
       background_color_(0),
       has_transparent_background_(false),
-      page_scale_layer_(NULL),
-      inner_viewport_scroll_layer_(NULL),
-      outer_viewport_scroll_layer_(NULL),
+      page_scale_layer_(nullptr),
+      inner_viewport_scroll_layer_(nullptr),
+      outer_viewport_scroll_layer_(nullptr),
       page_scale_factor_(1),
       page_scale_delta_(1),
       sent_page_scale_delta_(1),
       min_page_scale_factor_(0),
       max_page_scale_factor_(0),
       scrolling_layer_id_from_previous_tree_(0),
       contents_textures_purged_(false),
       viewport_size_invalid_(false),
       needs_update_draw_properties_(true),
       needs_full_tree_sync_(true),
@@ skipping 19 matching lines @@
   root_layer_ = nullptr;
 }
 
 void LayerTreeImpl::ReleaseResources() {
   if (root_layer_)
     ReleaseResourcesRecursive(root_layer_.get());
 }
 
 void LayerTreeImpl::SetRootLayer(scoped_ptr<LayerImpl> layer) {
   if (inner_viewport_scroll_layer_)
-    inner_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
+    inner_viewport_scroll_layer_->SetScrollOffsetDelegate(nullptr);
   if (outer_viewport_scroll_layer_)
-    outer_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
+    outer_viewport_scroll_layer_->SetScrollOffsetDelegate(nullptr);
   inner_viewport_scroll_delegate_proxy_ = nullptr;
   outer_viewport_scroll_delegate_proxy_ = nullptr;
 
   root_layer_ = layer.Pass();
-  currently_scrolling_layer_ = NULL;
-  inner_viewport_scroll_layer_ = NULL;
-  outer_viewport_scroll_layer_ = NULL;
-  page_scale_layer_ = NULL;
+  currently_scrolling_layer_ = nullptr;
+  inner_viewport_scroll_layer_ = nullptr;
+  outer_viewport_scroll_layer_ = nullptr;
+  page_scale_layer_ = nullptr;
 
   layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 }
 
 LayerImpl* LayerTreeImpl::InnerViewportScrollLayer() const {
   return inner_viewport_scroll_layer_;
 }
 
 LayerImpl* LayerTreeImpl::OuterViewportScrollLayer() const {
   return outer_viewport_scroll_layer_;
@@ skipping 30 matching lines @@
     delta += outer_viewport_scroll_layer_->ScrollDelta();
 
   return delta;
 }
 
 scoped_ptr<LayerImpl> LayerTreeImpl::DetachLayerTree() {
   // Clear all data structures that have direct references to the layer tree.
   scrolling_layer_id_from_previous_tree_ =
     currently_scrolling_layer_ ? currently_scrolling_layer_->id() : 0;
   if (inner_viewport_scroll_layer_)
-    inner_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
+    inner_viewport_scroll_layer_->SetScrollOffsetDelegate(nullptr);
   if (outer_viewport_scroll_layer_)
-    outer_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
+    outer_viewport_scroll_layer_->SetScrollOffsetDelegate(nullptr);
   inner_viewport_scroll_delegate_proxy_ = nullptr;
   outer_viewport_scroll_delegate_proxy_ = nullptr;
-  inner_viewport_scroll_layer_ = NULL;
-  outer_viewport_scroll_layer_ = NULL;
-  page_scale_layer_ = NULL;
-  currently_scrolling_layer_ = NULL;
+  inner_viewport_scroll_layer_ = nullptr;
+  outer_viewport_scroll_layer_ = nullptr;
+  page_scale_layer_ = nullptr;
+  currently_scrolling_layer_ = nullptr;
 
   render_surface_layer_list_.clear();
   set_needs_update_draw_properties();
   return root_layer_.Pass();
 }
 
 void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) {
   // The request queue should have been processed and does not require a push.
   DCHECK_EQ(ui_resource_request_queue_.size(), 0u);
 
@@ skipping 44 matching lines @@
   if (ViewportSizeInvalid())
     target_tree->SetViewportSizeInvalid();
   else
     target_tree->ResetViewportSizeInvalid();
 
   if (hud_layer())
     target_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(
         LayerTreeHostCommon::FindLayerInSubtree(
             target_tree->root_layer(), hud_layer()->id())));
   else
-    target_tree->set_hud_layer(NULL);
+    target_tree->set_hud_layer(nullptr);
 
   target_tree->has_ever_been_drawn_ = false;
 }
 
 LayerImpl* LayerTreeImpl::InnerViewportContainerLayer() const {
   return inner_viewport_scroll_layer_
              ? inner_viewport_scroll_layer_->scroll_clip_layer()
-             : NULL;
+             : nullptr;
 }
 
 LayerImpl* LayerTreeImpl::CurrentlyScrollingLayer() const {
   DCHECK(IsActiveTree());
   return currently_scrolling_layer_;
 }
 
 void LayerTreeImpl::SetCurrentlyScrollingLayer(LayerImpl* layer) {
   if (currently_scrolling_layer_ == layer)
     return;
 
   if (currently_scrolling_layer_ &&
       currently_scrolling_layer_->scrollbar_animation_controller())
     currently_scrolling_layer_->scrollbar_animation_controller()
         ->DidScrollEnd();
   currently_scrolling_layer_ = layer;
   if (layer && layer->scrollbar_animation_controller())
     layer->scrollbar_animation_controller()->DidScrollBegin();
 }
 
 void LayerTreeImpl::ClearCurrentlyScrollingLayer() {
-  SetCurrentlyScrollingLayer(NULL);
+  SetCurrentlyScrollingLayer(nullptr);
   scrolling_layer_id_from_previous_tree_ = 0;
 }
 
 namespace {
 
 void ForceScrollbarParameterUpdateAfterScaleChange(LayerImpl* current_layer) {
   if (!current_layer)
     return;
 
   while (current_layer) {
@@ skipping 143 matching lines @@
                                          this));
 
   if (outer_viewport_scroll_layer_)
     outer_viewport_scroll_delegate_proxy_ = make_scoped_ptr(
         new LayerScrollOffsetDelegateProxy(outer_viewport_scroll_layer_,
                                            root_layer_scroll_offset_delegate_,
                                            this));
 }
 
 void LayerTreeImpl::ClearViewportLayers() {
-  page_scale_layer_ = NULL;
-  inner_viewport_scroll_layer_ = NULL;
-  outer_viewport_scroll_layer_ = NULL;
+  page_scale_layer_ = nullptr;
+  inner_viewport_scroll_layer_ = nullptr;
+  outer_viewport_scroll_layer_ = nullptr;
 }
 
 bool LayerTreeImpl::UpdateDrawProperties() {
   if (!needs_update_draw_properties_)
     return true;
 
   // For max_texture_size.
   if (!layer_tree_host_impl_->renderer())
     return false;
 
@@ skipping 109 matching lines @@
   LayerImpl* root_scroll_layer = OuterViewportScrollLayer()
                                      ? OuterViewportScrollLayer()
                                      : InnerViewportScrollLayer();
   if (!root_scroll_layer || root_scroll_layer->children().empty())
     return gfx::Size();
   return root_scroll_layer->children()[0]->bounds();
 }
 
 LayerImpl* LayerTreeImpl::LayerById(int id) {
   LayerIdMap::iterator iter = layer_id_map_.find(id);
-  return iter != layer_id_map_.end() ? iter->second : NULL;
+  return iter != layer_id_map_.end() ? iter->second : nullptr;
 }
 
 void LayerTreeImpl::RegisterLayer(LayerImpl* layer) {
   DCHECK(!LayerById(layer->id()));
   layer_id_map_[layer->id()] = layer;
 }
 
 void LayerTreeImpl::UnregisterLayer(LayerImpl* layer) {
   DCHECK(LayerById(layer->id()));
   layer_id_map_.erase(layer->id());
@@ skipping 130 matching lines @@
   return layer_tree_host_impl_->pending_tree() == this;
 }
 
 bool LayerTreeImpl::IsRecycleTree() const {
   return layer_tree_host_impl_->recycle_tree() == this;
 }
 
 LayerImpl* LayerTreeImpl::FindActiveTreeLayerById(int id) {
   LayerTreeImpl* tree = layer_tree_host_impl_->active_tree();
   if (!tree)
-    return NULL;
+    return nullptr;
   return tree->LayerById(id);
 }
 
 LayerImpl* LayerTreeImpl::FindPendingTreeLayerById(int id) {
   LayerTreeImpl* tree = layer_tree_host_impl_->pending_tree();
   if (!tree)
-    return NULL;
+    return nullptr;
   return tree->LayerById(id);
 }
 
 LayerImpl* LayerTreeImpl::FindRecycleTreeLayerById(int id) {
   LayerTreeImpl* tree = layer_tree_host_impl_->recycle_tree();
   if (!tree)
-    return NULL;
+    return nullptr;
   return tree->LayerById(id);
 }
 
 bool LayerTreeImpl::PinchGestureActive() const {
   return layer_tree_host_impl_->pinch_gesture_active();
 }
 
 BeginFrameArgs LayerTreeImpl::CurrentBeginFrameArgs() const {
   return layer_tree_host_impl_->CurrentBeginFrameArgs();
 }
@@ skipping 124 matching lines @@
 
 void LayerTreeImpl::SetRootLayerScrollOffsetDelegate(
     LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) {
   if (root_layer_scroll_offset_delegate_ == root_layer_scroll_offset_delegate)
     return;
 
   if (!root_layer_scroll_offset_delegate) {
     // Make sure we remove the proxies from their layers before
     // releasing them.
     if (InnerViewportScrollLayer())
-      InnerViewportScrollLayer()->SetScrollOffsetDelegate(NULL);
+      InnerViewportScrollLayer()->SetScrollOffsetDelegate(nullptr);
     if (OuterViewportScrollLayer())
-      OuterViewportScrollLayer()->SetScrollOffsetDelegate(NULL);
+      OuterViewportScrollLayer()->SetScrollOffsetDelegate(nullptr);
     inner_viewport_scroll_delegate_proxy_ = nullptr;
     outer_viewport_scroll_delegate_proxy_ = nullptr;
   }
 
   root_layer_scroll_offset_delegate_ = root_layer_scroll_offset_delegate;
 
   if (root_layer_scroll_offset_delegate_) {
     root_layer_scroll_offset_delegate_->UpdateRootLayerState(
         TotalScrollOffset(),
         TotalMaxScrollOffset(),
@@ skipping 291 matching lines @@
 static bool PointIsClippedBySurfaceOrClipRect(
     const gfx::PointF& screen_space_point,
     const LayerImpl* layer) {
   // Walk up the layer tree and hit-test any render_surfaces and any layer
   // clip rects that are active.
   for (; layer; layer = GetNextClippingLayer(layer)) {
     if (layer->render_surface() &&
         !PointHitsRect(screen_space_point,
                        layer->render_surface()->screen_space_transform(),
                        layer->render_surface()->content_rect(),
-                       NULL))
+                       nullptr))
       return true;
 
     if (LayerClipsSubtree(layer) &&
         !PointHitsRect(screen_space_point,
                        layer->screen_space_transform(),
                        gfx::Rect(layer->content_bounds()),
-                       NULL))
+                       nullptr))
       return true;
   }
 
   // If we have finished walking all ancestors without having already exited,
   // then the point is not clipped by any ancestors.
   return false;
 }
 
 static bool PointHitsLayer(const LayerImpl* layer,
                            const gfx::PointF& screen_space_point,
@@ skipping 13 matching lines @@
 
   // Skip the HUD layer.
   if (layer == layer->layer_tree_impl()->hud_layer())
     return false;
 
   return true;
 }
 
 struct FindClosestMatchingLayerDataForRecursion {
   FindClosestMatchingLayerDataForRecursion()
-      : closest_match(NULL),
+      : closest_match(nullptr),
         closest_distance(-std::numeric_limits<float>::infinity()) {}
   LayerImpl* closest_match;
   // Note that the positive z-axis points towards the camera, so bigger means
   // closer in this case, counterintuitively.
   float closest_distance;
 };
 
 template <typename Functor>
 static void FindClosestMatchingLayer(
     const gfx::PointF& screen_space_point,
@@ skipping 53 matching lines @@
     return layer->IsDrawnRenderSurfaceLayerListMember() ||
            ScrollsAnyDrawnRenderSurfaceLayerListMember(layer) ||
            !layer->touch_event_handler_region().IsEmpty() ||
            layer->have_wheel_event_handlers();
   }
 };
 
 LayerImpl* LayerTreeImpl::FindLayerThatIsHitByPoint(
     const gfx::PointF& screen_space_point) {
   if (!root_layer())
-    return NULL;
+    return nullptr;
   if (!UpdateDrawProperties())
-    return NULL;
+    return nullptr;
   FindClosestMatchingLayerDataForRecursion data_for_recursion;
   FindClosestMatchingLayer(screen_space_point,
                            root_layer(),
                            HitTestVisibleScrollableOrTouchableFunctor(),
                            &data_for_recursion);
   return data_for_recursion.closest_match;
 }
 
 static bool LayerHasTouchEventHandlersAt(const gfx::PointF& screen_space_point,
                                          LayerImpl* layer_impl) {
@@ skipping 20 matching lines @@
 struct FindTouchEventLayerFunctor {
   bool operator()(LayerImpl* layer) const {
     return LayerHasTouchEventHandlersAt(screen_space_point, layer);
   }
   const gfx::PointF screen_space_point;
 };
 
 LayerImpl* LayerTreeImpl::FindLayerThatIsHitByPointInTouchHandlerRegion(
     const gfx::PointF& screen_space_point) {
   if (!root_layer())
-    return NULL;
+    return nullptr;
   if (!UpdateDrawProperties())
-    return NULL;
+    return nullptr;
   FindTouchEventLayerFunctor func = {screen_space_point};
   FindClosestMatchingLayerDataForRecursion data_for_recursion;
   FindClosestMatchingLayer(
       screen_space_point, root_layer(), func, &data_for_recursion);
   return data_for_recursion.closest_match;
 }
 
 void LayerTreeImpl::RegisterSelection(const LayerSelectionBound& start,
                                       const LayerSelectionBound& end) {
   selection_start_ = start;
@@ skipping 47 matching lines @@
   return viewport_bound;
 }
 
 void LayerTreeImpl::GetViewportSelection(ViewportSelectionBound* start,
                                          ViewportSelectionBound* end) {
   DCHECK(start);
   DCHECK(end);
 
   *start = ComputeViewportSelection(
       selection_start_,
-      selection_start_.layer_id ? LayerById(selection_start_.layer_id) : NULL,
+      selection_start_.layer_id ? LayerById(selection_start_.layer_id) : nullptr,
       device_scale_factor());
   if (start->type == SELECTION_BOUND_CENTER ||
       start->type == SELECTION_BOUND_EMPTY) {
     *end = *start;
   } else {
     *end = ComputeViewportSelection(
         selection_end_,
-        selection_end_.layer_id ? LayerById(selection_end_.layer_id) : NULL,
+        selection_end_.layer_id ? LayerById(selection_end_.layer_id) : nullptr,
         device_scale_factor());
   }
 }
 
 void LayerTreeImpl::RegisterPictureLayerImpl(PictureLayerImpl* layer) {
   layer_tree_host_impl_->RegisterPictureLayerImpl(layer);
 }
 
 void LayerTreeImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   layer_tree_host_impl_->UnregisterPictureLayerImpl(layer);
@@ skipping 42 matching lines @@
                                   page_scale,
                                   duration.InSecondsF());
   }
 }
 
 scoped_ptr<PageScaleAnimation> LayerTreeImpl::TakePageScaleAnimation() {
   return page_scale_animation_.Pass();
 }
 
 }  // namespace cc