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

cc/scheduler/begin_frame_source.cc

 // Copyright 2014 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/scheduler/begin_frame_source.h"
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_argument.h"
 #include "base/logging.h"
@@ skipping 43 matching lines @@
 void BeginFrameObserverMixIn::AsValueInto(
     base::debug::TracedValue* dict) const {
   dict->BeginDictionary("last_begin_frame_args_");
   last_begin_frame_args_.AsValueInto(dict);
   dict->EndDictionary();
   dict->SetInteger("dropped_begin_frame_args_", dropped_begin_frame_args_);
 }
 
 // BeginFrameSourceMixIn ------------------------------------------------------
 BeginFrameSourceMixIn::BeginFrameSourceMixIn()
-    : observer_(NULL),
+    : observer_(nullptr),
       needs_begin_frames_(false),
       inside_as_value_into_(false) {
   DCHECK(!observer_);
   DCHECK_EQ(inside_as_value_into_, false);
 }
 
 bool BeginFrameSourceMixIn::NeedsBeginFrames() const {
   return needs_begin_frames_;
 }
 
@@ skipping 19 matching lines @@
   observer_ = obs;
 }
 
 void BeginFrameSourceMixIn::RemoveObserver(BeginFrameObserver* obs) {
   DEBUG_FRAMES("BeginFrameSourceMixIn::RemoveObserver",
                "current observer",
                observer_,
                "to remove observer",
                obs);
   DCHECK_EQ(observer_, obs);
-  observer_ = NULL;
+  observer_ = nullptr;
 }
 
 void BeginFrameSourceMixIn::CallOnBeginFrame(const BeginFrameArgs& args) {
   DEBUG_FRAMES("BeginFrameSourceMixIn::CallOnBeginFrame",
                "current observer",
                observer_,
                "args",
                args.AsValue());
   if (observer_) {
     return observer_->OnBeginFrame(args);
   }
 }
 
 // Tracing support
 void BeginFrameSourceMixIn::AsValueInto(base::debug::TracedValue* dict) const {
   // As the observer might try to trace the source, prevent an infinte loop
   // from occuring.
   if (inside_as_value_into_) {
     dict->SetString("observer", "<loop detected>");
     return;
   }
 
   if (observer_) {
     base::AutoReset<bool> prevent_loops(
         const_cast<bool*>(&inside_as_value_into_), true);
     dict->BeginDictionary("observer");
     observer_->AsValueInto(dict);
     dict->EndDictionary();
   } else {
-    dict->SetString("observer", "NULL");
+    dict->SetString("observer", "nullptr");

[viettrungluu, 2014/10/10 17:16:20]

WAT

[danakj, 2014/10/10 17:18:52]

This will change the output of tracing to show nullptr instead of NULL. Idk that
either is better than the other in this case.

You're right that nullptr in a comment is usually better written as null though,
I need to go back and look for that.

   }
   dict->SetBoolean("needs_begin_frames", NeedsBeginFrames());
 }
 
 // BackToBackBeginFrameSourceMixIn --------------------------------------------
 scoped_ptr<BackToBackBeginFrameSource> BackToBackBeginFrameSource::Create(
     base::SingleThreadTaskRunner* task_runner) {
   return make_scoped_ptr(new BackToBackBeginFrameSource(task_runner));
 }
 
@@ skipping 135 matching lines @@
 }
 
 // BeginFrameSourceMultiplexer -------------------------------------------
 scoped_ptr<BeginFrameSourceMultiplexer> BeginFrameSourceMultiplexer::Create() {
   return make_scoped_ptr(new BeginFrameSourceMultiplexer());
 }
 
 BeginFrameSourceMultiplexer::BeginFrameSourceMultiplexer()
     : BeginFrameSourceMixIn(),
       minimum_interval_(base::TimeDelta()),
-      active_source_(NULL),
+      active_source_(nullptr),
       source_list_() {
 }
 
 BeginFrameSourceMultiplexer::BeginFrameSourceMultiplexer(
     base::TimeDelta minimum_interval)
     : BeginFrameSourceMixIn(),
       minimum_interval_(minimum_interval),
-      active_source_(NULL),
+      active_source_(nullptr),
       source_list_() {
 }
 
 BeginFrameSourceMultiplexer::~BeginFrameSourceMultiplexer() {
 }
 
 void BeginFrameSourceMultiplexer::SetMinimumInterval(
     base::TimeDelta new_minimum_interval) {
   DEBUG_FRAMES("BeginFrameSourceMultiplexer::SetMinimumInterval",
                "current minimum (us)",
@@ skipping 34 matching lines @@
 }
 
 void BeginFrameSourceMultiplexer::SetActiveSource(
     BeginFrameSource* new_source) {
   DEBUG_FRAMES("BeginFrameSourceMultiplexer::SetActiveSource",
                "current active",
                active_source_,
                "to become active",
                new_source);
 
-  DCHECK(HasSource(new_source) || new_source == NULL);
+  DCHECK(HasSource(new_source) || new_source == nullptr);
 
   bool needs_begin_frames = NeedsBeginFrames();
   if (active_source_) {
     if (needs_begin_frames)
       SetNeedsBeginFrames(false);
 
     // Technically we shouldn't need to remove observation, but this prevents
     // the case where SetNeedsBeginFrames message gets to the source after a
     // message has already been sent.
     active_source_->RemoveObserver(this);
-    active_source_ = NULL;
+    active_source_ = nullptr;
   }
   DCHECK(!active_source_);
   active_source_ = new_source;
 
   if (active_source_) {
     active_source_->AddObserver(this);
 
     if (needs_begin_frames) {
       SetNeedsBeginFrames(true);
     }
@@ skipping 73 matching lines @@
     dict->BeginDictionary("last_begin_frame_args");
     observer_->LastUsedBeginFrameArgs().AsValueInto(dict);
     dict->EndDictionary();
   }
 
   if (active_source_) {
     dict->BeginDictionary("active_source");
     active_source_->AsValueInto(dict);
     dict->EndDictionary();
   } else {
-    dict->SetString("active_source", "NULL");
+    dict->SetString("active_source", "nullptr");

[viettrungluu, 2014/10/10 17:16:20]

"

   }
 
   dict->BeginArray("sources");
   for (std::set<BeginFrameSource*>::const_iterator it = source_list_.begin();
        it != source_list_.end();
        ++it) {
     dict->BeginDictionary();
     (*it)->AsValueInto(dict);
     dict->EndDictionary();
   }
@@ skipping 14 matching lines @@
   if (!observer_->LastUsedBeginFrameArgs().IsValid())
     return true;
 
   // Only allow new args have a *strictly bigger* frame_time value and statisfy
   // minimum interval requirement.
   return (args.frame_time >=
           observer_->LastUsedBeginFrameArgs().frame_time + minimum_interval_);
 }
 
 }  // namespace cc