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

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 <limits>
 
 #include "base/basictypes.h"
@@ skipping 123 matching lines @@
 class LayerTreeHostImplTimeSourceAdapter : public TimeSourceClient {
  public:
   static scoped_ptr<LayerTreeHostImplTimeSourceAdapter> Create(
       LayerTreeHostImpl* layer_tree_host_impl,
       scoped_refptr<DelayBasedTimeSource> time_source) {
     return make_scoped_ptr(
         new LayerTreeHostImplTimeSourceAdapter(layer_tree_host_impl,
                                                time_source));
   }
   virtual ~LayerTreeHostImplTimeSourceAdapter() {
-    time_source_->SetClient(NULL);
+    time_source_->SetClient(nullptr);
     time_source_->SetActive(false);
   }
 
   virtual void OnTimerTick() override {
     // In single threaded mode we attempt to simulate changing the current
     // thread by maintaining a fake thread id. When we switch from one
     // thread to another, we construct DebugScopedSetXXXThread objects that
     // update the thread id. This lets DCHECKS that ensure we're on the
     // right thread to work correctly in single threaded mode. The problem
     // here is that the timer tasks are run via the message loop, and when
@@ skipping 67 matching lines @@
     const LayerTreeSettings& settings,
     LayerTreeHostImplClient* client,
     Proxy* proxy,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     SharedBitmapManager* manager,
     int id)
     : BeginFrameSourceMixIn(),
       client_(client),
       proxy_(proxy),
       use_gpu_rasterization_(false),
-      input_handler_client_(NULL),
+      input_handler_client_(nullptr),
       did_lock_scrolling_layer_(false),
       should_bubble_scrolls_(false),
       wheel_scrolling_(false),
       scroll_affects_scroll_handler_(false),
       scroll_layer_id_when_mouse_over_scrollbar_(0),
       tile_priorities_dirty_(false),
-      root_layer_scroll_offset_delegate_(NULL),
+      root_layer_scroll_offset_delegate_(nullptr),
       settings_(settings),
       visible_(true),
       cached_managed_memory_policy_(
           PrioritizedResourceManager::DefaultMemoryAllocationLimit(),
           gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
           ManagedMemoryPolicy::kDefaultNumResourcesLimit),
       pinch_gesture_active_(false),
       pinch_gesture_end_should_clear_scrolling_layer_(false),
       fps_counter_(FrameRateCounter::Create(proxy_->HasImplThread())),
       paint_time_counter_(PaintTimeCounter::Create()),
@@ skipping 43 matching lines @@
 }
 
 LayerTreeHostImpl::~LayerTreeHostImpl() {
   DCHECK(proxy_->IsImplThread());
   TRACE_EVENT0("cc", "LayerTreeHostImpl::~LayerTreeHostImpl()");
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerTreeHostImpl", id_);
 
   if (input_handler_client_) {
     input_handler_client_->WillShutdown();
-    input_handler_client_ = NULL;
+    input_handler_client_ = nullptr;
   }
 
   // The layer trees 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.
   if (recycle_tree_)
     recycle_tree_->Shutdown();
   if (pending_tree_)
     pending_tree_->Shutdown();
   active_tree_->Shutdown();
@@ skipping 55 matching lines @@
   // affect the result of CanDraw, make sure to call
   // client_->OnCanDrawStateChanged in the proper places and update the
   // NotifyIfCanDrawChanged test.
 
   if (!renderer_) {
     TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no renderer",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
-  // Must have an OutputSurface if |renderer_| is not NULL.
+  // Must have an OutputSurface if |renderer_| is not nullptr.
   DCHECK(output_surface_);
 
   // TODO(boliu): Make draws without root_layer work and move this below
   // draw_and_swap_full_viewport_every_frame check. Tracked in crbug.com/264967.
   if (!active_tree_->root_layer()) {
     TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no root layer",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
@@ skipping 54 matching lines @@
     return false;
 
   gfx::PointF device_viewport_point =
       gfx::ScalePoint(viewport_point, device_scale_factor_);
 
   LayerImpl* layer_impl =
       active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
 
   bool scroll_on_main_thread = false;
   LayerImpl* scrolling_layer_impl = FindScrollLayerForDeviceViewportPoint(
-      device_viewport_point, type, layer_impl, &scroll_on_main_thread, NULL);
+      device_viewport_point, type, layer_impl, &scroll_on_main_thread, nullptr);
   return CurrentlyScrollingLayer() == scrolling_layer_impl;
 }
 
 bool LayerTreeHostImpl::HaveTouchEventHandlersAt(
     const gfx::Point& viewport_point) {
 
   gfx::PointF device_viewport_point =
       gfx::ScalePoint(viewport_point, device_scale_factor_);
 
   LayerImpl* layer_impl =
       active_tree_->FindLayerThatIsHitByPointInTouchHandlerRegion(
           device_viewport_point);
 
-  return layer_impl != NULL;
+  return layer_impl != nullptr;
 }
 
 scoped_ptr<SwapPromiseMonitor>
 LayerTreeHostImpl::CreateLatencyInfoSwapPromiseMonitor(
     ui::LatencyInfo* latency) {
   return make_scoped_ptr(
-      new LatencyInfoSwapPromiseMonitor(latency, NULL, this));
+      new LatencyInfoSwapPromiseMonitor(latency, nullptr, this));
 }
 
 void LayerTreeHostImpl::QueueSwapPromiseForMainThreadScrollUpdate(
     scoped_ptr<SwapPromise> swap_promise) {
   swap_promises_for_main_thread_scroll_update_.push_back(swap_promise.Pass());
 }
 
 void LayerTreeHostImpl::TrackDamageForAllSurfaces(
     LayerImpl* root_draw_layer,
     const LayerImplList& render_surface_layer_list) {
@@ skipping 223 matching lines @@
 
   // Create the render passes in dependency order.
   for (int surface_index = frame->render_surface_layer_list->size() - 1;
        surface_index >= 0;
        --surface_index) {
     LayerImpl* render_surface_layer =
         (*frame->render_surface_layer_list)[surface_index];
     RenderSurfaceImpl* render_surface = render_surface_layer->render_surface();
 
     bool should_draw_into_render_pass =
-        render_surface_layer->parent() == NULL ||
+        render_surface_layer->parent() == nullptr ||
         render_surface->contributes_to_drawn_surface() ||
         render_surface_layer->HasCopyRequest();
     if (should_draw_into_render_pass)
       render_surface_layer->render_surface()->AppendRenderPasses(frame);
   }
 
   // When we are displaying the HUD, change the root damage rect to cover the
   // entire root surface. This will disable partial-swap/scissor optimizations
   // that would prevent the HUD from updating, since the HUD does not cause
   // damage itself, to prevent it from messing with damage visualizations. Since
@@ skipping 227 matching lines @@
 
 void LayerTreeHostImpl::SetViewportDamage(const gfx::Rect& damage_rect) {
   viewport_damage_rect_.Union(damage_rect);
 }
 
 static inline RenderPass* FindRenderPassById(
     RenderPassId render_pass_id,
     const LayerTreeHostImpl::FrameData& frame) {
   RenderPassIdHashMap::const_iterator it =
       frame.render_passes_by_id.find(render_pass_id);
-  return it != frame.render_passes_by_id.end() ? it->second : NULL;
+  return it != frame.render_passes_by_id.end() ? it->second : nullptr;
 }
 
 static void RemoveRenderPassesRecursive(RenderPassId remove_render_pass_id,
                                         LayerTreeHostImpl::FrameData* frame) {
   RenderPass* remove_render_pass =
       FindRenderPassById(remove_render_pass_id, *frame);
   // The pass was already removed by another quad - probably the original, and
   // we are the replica.
   if (!remove_render_pass)
     return;
@@ skipping 266 matching lines @@
 
     // TODO(vmpstr): Iterators and should handle this instead. crbug.com/381704
     if (!layer->HasValidTilePriorities())
       continue;
 
     PictureLayerImpl* twin_layer = layer->GetTwinLayer();
 
     // Ignore the twin layer when tile priorities are invalid.
     // TODO(vmpstr): Iterators should handle this instead. crbug.com/381704
     if (twin_layer && !twin_layer->HasValidTilePriorities())
-      twin_layer = NULL;
+      twin_layer = nullptr;
 
     // If the current tree is ACTIVE_TREE, then always generate a layer_pair.
     // If current tree is PENDING_TREE, then only generate a layer_pair if
     // there is no twin layer.
     if (layer->GetTree() == ACTIVE_TREE) {
       DCHECK(!twin_layer || twin_layer->GetTree() == PENDING_TREE);
       layer_pairs->push_back(PictureLayerImpl::Pair(layer, twin_layer));
     } else if (!twin_layer) {
-      layer_pairs->push_back(PictureLayerImpl::Pair(NULL, layer));
+      layer_pairs->push_back(PictureLayerImpl::Pair(nullptr, layer));
     }
   }
 }
 
 void LayerTreeHostImpl::BuildRasterQueue(RasterTilePriorityQueue* queue,
                                          TreePriority tree_priority) {
   picture_layer_pairs_.clear();
   GetPictureLayerImplPairs(&picture_layer_pairs_);
   queue->Build(picture_layer_pairs_, tree_priority);
 }
@@ skipping 266 matching lines @@
     TRACE_EVENT0("cc", "DrawLayers.UpdateHudTexture");
     active_tree_->hud_layer()->UpdateHudTexture(draw_mode,
                                                 resource_provider_.get());
   }
 
   if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE) {
     bool disable_picture_quad_image_filtering =
         IsCurrentlyScrolling() || needs_animate_layers();
 
     scoped_ptr<SoftwareRenderer> temp_software_renderer =
-        SoftwareRenderer::Create(this, &settings_, output_surface_.get(), NULL);
+        SoftwareRenderer::Create(this, &settings_, output_surface_.get(), nullptr);

[danakj, 2014/10/09 16:00:53]

and here?

     temp_software_renderer->DrawFrame(&frame->render_passes,
                                       device_scale_factor_,
                                       DeviceViewport(),
                                       DeviceClip(),
                                       disable_picture_quad_image_filtering);
   } else {
     renderer_->DrawFrame(&frame->render_passes,
                          device_scale_factor_,
                          DeviceViewport(),
                          DeviceClip(),
@@ skipping 146 matching lines @@
           InnerViewportScrollLayer()->IsExternalFlingActive()) ||
          (OuterViewportScrollLayer() &&
           OuterViewportScrollLayer()->IsExternalFlingActive());
 }
 
 // Content layers can be either directly scrollable or contained in an outer
 // scrolling layer which applies the scroll transform. Given a content layer,
 // this function returns the associated scroll layer if any.
 static LayerImpl* FindScrollLayerForContentLayer(LayerImpl* layer_impl) {
   if (!layer_impl)
-    return NULL;
+    return nullptr;
 
   if (layer_impl->scrollable())
     return layer_impl;
 
   if (layer_impl->DrawsContent() &&
       layer_impl->parent() &&
       layer_impl->parent()->scrollable())
     return layer_impl->parent();
 
-  return NULL;
+  return nullptr;
 }
 
 void LayerTreeHostImpl::CreatePendingTree() {
   CHECK(!pending_tree_);
   if (recycle_tree_)
     recycle_tree_.swap(pending_tree_);
   else
     pending_tree_ = LayerTreeImpl::create(this);
 
   // Update the delta from the active tree, which may have
@@ skipping 15 matching lines @@
     DidInitializeVisibleTile();
   need_to_update_visible_tiles_before_draw_ = false;
 }
 
 void LayerTreeHostImpl::ActivateSyncTree() {
   need_to_update_visible_tiles_before_draw_ = true;
 
   if (pending_tree_) {
     TRACE_EVENT_ASYNC_END0("cc", "PendingTree:waiting", pending_tree_.get());
 
-    active_tree_->SetRootLayerScrollOffsetDelegate(NULL);
+    active_tree_->SetRootLayerScrollOffsetDelegate(nullptr);
     active_tree_->PushPersistedState(pending_tree_.get());
     // Process any requests in the UI resource queue.  The request queue is
     // given in LayerTreeHost::FinishCommitOnImplThread.  This must take place
     // before the swap.
     pending_tree_->ProcessUIResourceRequestQueue();
 
     if (pending_tree_->needs_full_tree_sync()) {
       active_tree_->SetRootLayer(
           TreeSynchronizer::SynchronizeTrees(pending_tree_->root_layer(),
                                              active_tree_->DetachLayerTree(),
@@ skipping 444 matching lines @@
       top_controls_manager_->top_controls_height();
   active_tree_->set_top_controls_delta(offset - current_top_offset);
 }
 
 float LayerTreeHostImpl::ControlsTopOffset() const {
   return active_tree_->total_top_controls_content_offset() -
       top_controls_manager_->top_controls_height();
 }
 
 void LayerTreeHostImpl::BindToClient(InputHandlerClient* client) {
-  DCHECK(input_handler_client_ == NULL);
+  DCHECK(input_handler_client_ == nullptr);
   input_handler_client_ = client;
 }
 
 static LayerImpl* NextScrollLayer(LayerImpl* layer) {
   if (LayerImpl* scroll_parent = layer->scroll_parent())
     return scroll_parent;
   return layer->parent();
 }
 
 LayerImpl* LayerTreeHostImpl::FindScrollLayerForDeviceViewportPoint(
     const gfx::PointF& device_viewport_point,
     InputHandler::ScrollInputType type,
     LayerImpl* layer_impl,
     bool* scroll_on_main_thread,
     bool* optional_has_ancestor_scroll_handler) const {
   DCHECK(scroll_on_main_thread);
 
   // Walk up the hierarchy and look for a scrollable layer.
-  LayerImpl* potentially_scrolling_layer_impl = NULL;
+  LayerImpl* potentially_scrolling_layer_impl = nullptr;
   for (; layer_impl; layer_impl = NextScrollLayer(layer_impl)) {
     // The content layer can also block attempts to scroll outside the main
     // thread.
     ScrollStatus status = layer_impl->TryScroll(device_viewport_point, type);
     if (status == ScrollOnMainThread) {
       *scroll_on_main_thread = true;
-      return NULL;
+      return nullptr;
     }
 
     LayerImpl* scroll_layer_impl = FindScrollLayerForContentLayer(layer_impl);
     if (!scroll_layer_impl)
       continue;
 
     status = scroll_layer_impl->TryScroll(device_viewport_point, type);
     // If any layer wants to divert the scroll event to the main thread, abort.
     if (status == ScrollOnMainThread) {
       *scroll_on_main_thread = true;
-      return NULL;
+      return nullptr;
     }
 
     if (optional_has_ancestor_scroll_handler &&
         scroll_layer_impl->have_scroll_event_handlers())
       *optional_has_ancestor_scroll_handler = true;
 
     if (status == ScrollStarted && !potentially_scrolling_layer_impl)
       potentially_scrolling_layer_impl = scroll_layer_impl;
   }
 
@@ skipping 411 matching lines @@
 }
 
 void LayerTreeHostImpl::SetRootLayerScrollOffsetDelegate(
       LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) {
   root_layer_scroll_offset_delegate_ = root_layer_scroll_offset_delegate;
   active_tree_->SetRootLayerScrollOffsetDelegate(
       root_layer_scroll_offset_delegate_);
 }
 
 void LayerTreeHostImpl::OnRootLayerDelegatedScrollOffsetChanged() {
-  DCHECK(root_layer_scroll_offset_delegate_ != NULL);
+  DCHECK(root_layer_scroll_offset_delegate_ != nullptr);
   client_->SetNeedsCommitOnImplThread();
   active_tree_->set_needs_update_draw_properties();
 }
 
 void LayerTreeHostImpl::ClearCurrentlyScrollingLayer() {
   active_tree_->ClearCurrentlyScrollingLayer();
   did_lock_scrolling_layer_ = false;
   scroll_affects_scroll_handler_ = false;
   accumulated_root_overscroll_ = gfx::Vector2dF();
 }
@@ skipping 52 matching lines @@
 
   if (scroll_layer_id_when_mouse_over_scrollbar_) {
     LayerImpl* scroll_layer_impl = active_tree_->LayerById(
         scroll_layer_id_when_mouse_over_scrollbar_);
 
     // The check for a null scroll_layer_impl below was added to see if it will
     // eliminate the crashes described in http://crbug.com/326635.
     // TODO(wjmaclean) Add a unit test if this fixes the crashes.
     ScrollbarAnimationController* animation_controller =
         scroll_layer_impl ? scroll_layer_impl->scrollbar_animation_controller()
-                          : NULL;
+                          : nullptr;
     if (animation_controller)
       animation_controller->DidMouseMoveOffScrollbar();
     scroll_layer_id_when_mouse_over_scrollbar_ = 0;
   }
 
   bool scroll_on_main_thread = false;
   LayerImpl* scroll_layer_impl =
       FindScrollLayerForDeviceViewportPoint(device_viewport_point,
                                             InputHandler::Gesture,
                                             layer_impl,
                                             &scroll_on_main_thread,
-                                            NULL);
+                                            nullptr);
   if (scroll_on_main_thread || !scroll_layer_impl)
     return;
 
   ScrollbarAnimationController* animation_controller =
       scroll_layer_impl->scrollbar_animation_controller();
   if (!animation_controller)
     return;
 
   // TODO(wjmaclean) Is it ok to choose distance from more than two scrollbars?
   float distance_to_scrollbar = std::numeric_limits<float>::max();
@@ skipping 46 matching lines @@
 void LayerTreeHostImpl::PinchGestureUpdate(float magnify_delta,
                                            const gfx::Point& anchor) {
   if (!InnerViewportScrollLayer())
     return;
 
   TRACE_EVENT0("cc", "LayerTreeHostImpl::PinchGestureUpdate");
 
   // For a moment the scroll offset ends up being outside of the max range. This
   // confuses the delegate so we switch it off till after we're done processing
   // the pinch update.
-  active_tree_->SetRootLayerScrollOffsetDelegate(NULL);
+  active_tree_->SetRootLayerScrollOffsetDelegate(nullptr);
 
   // Keep the center-of-pinch anchor specified by (x, y) in a stable
   // position over the course of the magnify.
   float page_scale_delta = active_tree_->page_scale_delta();
   gfx::PointF previous_scale_anchor =
       gfx::ScalePoint(anchor, 1.f / page_scale_delta);
   active_tree_->SetPageScaleDelta(page_scale_delta * magnify_delta);
   page_scale_delta = active_tree_->page_scale_delta();
   gfx::PointF new_scale_anchor =
       gfx::ScalePoint(anchor, 1.f / page_scale_delta);
@@ skipping 278 matching lines @@
   // we're not in a frame (because this is during an input event or a delayed
   // task), fall back to physical time.  This should still be monotonic.
   if (current_begin_frame_args_.IsValid())
     return current_begin_frame_args_;
   return BeginFrameArgs::Create(gfx::FrameTime::Now(),
                                 base::TimeTicks(),
                                 BeginFrameArgs::DefaultInterval());
 }
 
 void LayerTreeHostImpl::AsValueInto(base::debug::TracedValue* value) const {
-  return AsValueWithFrameInto(NULL, value);
+  return AsValueWithFrameInto(nullptr, value);
 }
 
 scoped_refptr<base::debug::ConvertableToTraceFormat>
 LayerTreeHostImpl::AsValue() const {
-  return AsValueWithFrame(NULL);
+  return AsValueWithFrame(nullptr);
 }
 
 scoped_refptr<base::debug::ConvertableToTraceFormat>
 LayerTreeHostImpl::AsValueWithFrame(FrameData* frame) const {
   scoped_refptr<base::debug::TracedValue> state =
       new base::debug::TracedValue();
   AsValueWithFrameInto(frame, state.get());
   return state;
 }
 
@@ skipping 215 matching lines @@
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc