NULL -> nullptr under athena/

athena/input/accelerator_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/input/accelerator_manager_impl.h"
 
 #include "athena/input/public/input_manager.h"
 #include "athena/util/switches.h"
 #include "base/logging.h"
 #include "ui/aura/window.h"
@@ skipping 84 matching lines @@
   virtual ~FocusManagerDelegate() {}
 
   virtual bool ProcessAccelerator(const ui::Accelerator& accelerator) override {
     return accelerator_manager_->Process(accelerator);
   }
 
   virtual ui::AcceleratorTarget* GetCurrentTargetForAccelerator(
       const ui::Accelerator& accelerator) const override {
     return accelerator_manager_->IsRegistered(accelerator, AF_NONE)
                ? accelerator_manager_
-               : NULL;
+               : nullptr;
   }
 
  private:
   AcceleratorManagerImpl* accelerator_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusManagerDelegate);
 };
 
 // Key strokes must be sent to web contents to give them a chance to
 // consume them unless they are reserved, and unhandled key events are
 // sent back to focus manager asynchronously. This installs the athena's
 // focus manager that handles athena shell's accelerators.
 class FocusManagerFactory : public views::FocusManagerFactory {
  public:
   explicit FocusManagerFactory(AcceleratorManagerImpl* accelerator_manager)
       : accelerator_manager_(accelerator_manager) {}
   virtual ~FocusManagerFactory() {}
 
   virtual views::FocusManager* CreateFocusManager(
       views::Widget* widget,
       bool desktop_widget) override {
     return new views::FocusManager(
         widget,
-        desktop_widget ? NULL : new FocusManagerDelegate(accelerator_manager_));
+        desktop_widget ? nullptr
+                       : new FocusManagerDelegate(accelerator_manager_));
   }
 
  private:
   AcceleratorManagerImpl* accelerator_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusManagerFactory);
 };
 
 class UIAcceleratorManagerWrapper
     : public AcceleratorManagerImpl::AcceleratorWrapper {
@@ skipping 99 matching lines @@
   return scoped_ptr<AcceleratorManager>(
              new AcceleratorManagerImpl(new FocusManagerWrapper(focus_manager)))
       .Pass();
 }
 
 AcceleratorManagerImpl::~AcceleratorManagerImpl() {
   nested_accelerator_controller_.reset();
   accelerator_filter_.reset();
   // Reset to use the default focus manager because the athena's
   // FocusManager has the reference to this object.
-  views::FocusManagerFactory::Install(NULL);
+  views::FocusManagerFactory::Install(nullptr);
 }
 
 void AcceleratorManagerImpl::Init() {
   views::FocusManagerFactory::Install(new FocusManagerFactory(this));
 
   ui::EventTarget* toplevel = InputManager::Get()->GetTopmostEventTarget();
   nested_accelerator_controller_.reset(
       new wm::NestedAcceleratorController(new NestedAcceleratorDelegate(this)));
 
   scoped_ptr<wm::AcceleratorDelegate> accelerator_delegate(
@@ skipping 93 matching lines @@
   return InputManager::Get()->GetAcceleratorManager();
 }
 
 // static
 scoped_ptr<AcceleratorManager> AcceleratorManager::CreateForFocusManager(
     views::FocusManager* focus_manager) {
   return AcceleratorManagerImpl::CreateForFocusManager(focus_manager).Pass();
 }
 
 }  // namespace athena