NULL -> nullptr under athena/

athena/screen/screen_manager_impl.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 "athena/screen/screen_manager_impl.h"
 
 #include "athena/input/public/accelerator_manager.h"
 #include "athena/screen/modal_window_controller.h"
 #include "athena/screen/screen_accelerator_handler.h"
 #include "athena/util/container_priorities.h"
@@ skipping 15 matching lines @@
 #include "ui/wm/core/window_util.h"
 
 // This is to avoid creating type definitoin for kAlwaysOnTopKey.
 DECLARE_EXPORTED_WINDOW_PROPERTY_TYPE(ATHENA_EXPORT, bool);
 
 namespace athena {
 namespace {
 
 DEFINE_OWNED_WINDOW_PROPERTY_KEY(ScreenManager::ContainerParams,
                                  kContainerParamsKey,
-                                 NULL);
+                                 nullptr);
 
-ScreenManagerImpl* instance = NULL;
+ScreenManagerImpl* instance = nullptr;
 
 // A functor to find a container that has the higher priority.
 struct HigherPriorityFinder {
   HigherPriorityFinder(int p) : priority(p) {}
   bool operator()(aura::Window* window) {
     return window->GetProperty(kContainerParamsKey)->z_order_priority >
            priority;
   }
   int priority;
 };
@@ skipping 55 matching lines @@
         if (BlockEvents(*iter))
           return false;
       }
     }
     return BaseFocusRules::CanActivateWindow(window);
   }
 
   virtual aura::Window* GetNextActivatableWindow(
       aura::Window* ignore) const override {
     aura::Window* next = wm::BaseFocusRules::GetNextActivatableWindow(ignore);
-    // TODO(oshima): Search from activatable containers if |next| is NULL.
+    // TODO(oshima): Search from activatable containers if |next| is nullptr.
     // crbug.com/424750.
     return next;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AthenaFocusRules);
 };
 
 class AthenaScreenPositionClient : public aura::client::ScreenPositionClient {
  public:
@@ skipping 63 matching lines @@
       ui::EventTarget* root,
       ui::LocatedEvent* event) override {
     ui::EventTarget* target =
         aura::WindowTargeter::FindTargetForLocatedEvent(root, event);
     if (target)
       return target;
     // If the root target is blocking the event, return the container even if
     // there is no target found so that windows behind it will not be searched.
     const ScreenManager::ContainerParams* params =
         static_cast<aura::Window*>(root)->GetProperty(kContainerParamsKey);
-    return (params && params->block_events) ? root : NULL;
+    return (params && params->block_events) ? root : nullptr;
   }
 
   // Not owned.
   aura::Window* root_window_;
 
   DISALLOW_COPY_AND_ASSIGN(AthenaWindowTargeter);
 };
 
 }  // namespace
 
 ScreenManagerImpl::ScreenManagerImpl(aura::Window* root_window)
     : root_window_(root_window),
       last_requested_rotation_(gfx::Display::ROTATE_0),
       rotation_locked_(false) {
   DCHECK(root_window_);
   DCHECK(!instance);
   instance = this;
 }
 
 ScreenManagerImpl::~ScreenManagerImpl() {
-  aura::client::SetScreenPositionClient(root_window_, NULL);
-  aura::client::SetWindowTreeClient(root_window_, NULL);
+  aura::client::SetScreenPositionClient(root_window_, nullptr);
+  aura::client::SetWindowTreeClient(root_window_, nullptr);
   wm::FocusController* focus_controller =
       static_cast<wm::FocusController*>(focus_client_.get());
   root_window_->RemovePreTargetHandler(focus_controller);
-  aura::client::SetActivationClient(root_window_, NULL);
-  aura::client::SetFocusClient(root_window_, NULL);
+  aura::client::SetActivationClient(root_window_, nullptr);
+  aura::client::SetFocusClient(root_window_, nullptr);
   aura::Window::Windows children = root_window_->children();
   // Close All children:
   for (aura::Window::Windows::iterator iter = children.begin();
        iter != children.end();
        ++iter) {
     delete *iter;
   }
-  instance = NULL;
+  instance = nullptr;
 }
 
 void ScreenManagerImpl::Init() {
   wm::FocusController* focus_controller =
       new wm::FocusController(new AthenaFocusRules());
 
   aura::client::SetFocusClient(root_window_, focus_controller);
   root_window_->AddPreTargetHandler(focus_controller);
   aura::client::SetActivationClient(root_window_, focus_controller);
   focus_client_.reset(focus_controller);
 
   root_window_->SetLayoutManager(new FillLayoutManager(root_window_));
   capture_client_.reset(new ::wm::ScopedCaptureClient(root_window_));
   accelerator_handler_.reset(new ScreenAcceleratorHandler(root_window_));
 
   aura::client::SetWindowTreeClient(root_window_, this);
 
   screen_position_client_.reset(new AthenaScreenPositionClient());
   aura::client::SetScreenPositionClient(root_window_,
                                         screen_position_client_.get());
   root_window_->SetEventTargeter(
       make_scoped_ptr(new AthenaWindowTargeter(root_window_)));
 }
 
 aura::Window* ScreenManagerImpl::FindContainerByPriority(int priority) {
   for (aura::Window* window : root_window_->children()) {
     if (window->GetProperty(kContainerParamsKey)->z_order_priority == priority)
       return window;
   }
-  return NULL;
+  return nullptr;
 }
 
 aura::Window* ScreenManagerImpl::CreateContainer(
     const ContainerParams& params) {
   const aura::Window::Windows& children = root_window_->children();
 
   if (params.default_parent) {
     CHECK(std::find_if(children.begin(), children.end(), &DefaultContainer) ==
           children.end());
   }
   // mmodal container's priority must be higher than the container's priority.
   DCHECK(params.modal_container_priority == -1 ||
          params.modal_container_priority > params.z_order_priority);
   // Default parent must specify modal_container_priority.
   DCHECK(!params.default_parent || params.modal_container_priority != -1);
 
-  aura::Window* container = new aura::Window(NULL);
+  aura::Window* container = new aura::Window(nullptr);
   CHECK_GE(params.z_order_priority, 0);
   container->Init(aura::WINDOW_LAYER_NOT_DRAWN);
   container->SetName(params.name);
 
   DCHECK(!FindContainerByPriority(params.z_order_priority))
       << "The container with the priority " << params.z_order_priority
       << " already exists.";
 
   container->SetProperty(kContainerParamsKey, new ContainerParams(params));
 
@@ skipping 105 matching lines @@
 }
 
 // static
 void ScreenManager::Shutdown() {
   DCHECK(instance);
   delete instance;
   DCHECK(!instance);
 }
 
 }  // namespace athena