NULL -> nullptr under athena/

athena/home/home_card_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/home/home_card_impl.h"
 
 #include <cmath>
 #include <limits>
 
 #include "athena/env/public/athena_env.h"
@@ skipping 14 matching lines @@
 #include "ui/gfx/animation/tween.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/wm/core/shadow_types.h"
 #include "ui/wm/core/visibility_controller.h"
 
 namespace athena {
 namespace {
 
-HomeCard* instance = NULL;
+HomeCard* instance = nullptr;
 
 gfx::Rect GetBoundsForState(const gfx::Rect& screen_bounds,
                             HomeCard::State state) {
   switch (state) {
     case HomeCard::HIDDEN:
       break;
 
     case HomeCard::VISIBLE_CENTERED:
       return screen_bounds;
 
@@ skipping 14 matching lines @@
   NOTREACHED();
   return gfx::Rect();
 }
 
 }  // namespace
 
 // Makes sure the homecard is center-aligned horizontally and bottom-aligned
 // vertically.
 class HomeCardLayoutManager : public aura::LayoutManager {
  public:
-  HomeCardLayoutManager()
-      : home_card_(NULL),
-        minimized_layer_(NULL) {}
+  HomeCardLayoutManager() : home_card_(nullptr), minimized_layer_(nullptr) {}
 
   virtual ~HomeCardLayoutManager() {}
 
   void Layout(bool animate, gfx::Tween::Type tween_type) {
     // |home_card| could be detached from the root window (e.g. when it is being
     // destroyed).
     if (!home_card_ || !home_card_->IsVisible() || !home_card_->GetRootWindow())
       return;
 
     scoped_ptr<ui::ScopedLayerAnimationSettings> settings;
@@ skipping 26 matching lines @@
     UpdateMinimizedHomeBounds();
   }
   virtual void OnWindowAddedToLayout(aura::Window* child) override {
     if (!home_card_) {
       home_card_ = child;
       Layout(false, gfx::Tween::LINEAR);
     }
   }
   virtual void OnWillRemoveWindowFromLayout(aura::Window* child) override {
     if (home_card_ == child)
-      home_card_ = NULL;
+      home_card_ = nullptr;
   }
   virtual void OnWindowRemovedFromLayout(aura::Window* child) override {
   }
   virtual void OnChildWindowVisibilityChanged(aura::Window* child,
                                               bool visible) override {
     if (home_card_ == child)
       Layout(false, gfx::Tween::LINEAR);
   }
   virtual void SetChildBounds(aura::Window* child,
                               const gfx::Rect& requested_bounds) override {
@@ skipping 99 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(HomeCardView);
 };
 
 HomeCardImpl::HomeCardImpl(scoped_ptr<AppModelBuilder> model_builder,
                            scoped_ptr<SearchControllerFactory> search_factory)
     : model_builder_(model_builder.Pass()),
       search_factory_(search_factory.Pass()),
       state_(HIDDEN),
       original_state_(VISIBLE_MINIMIZED),
-      home_card_widget_(NULL),
-      home_card_view_(NULL),
-      layout_manager_(NULL) {
+      home_card_widget_(nullptr),
+      home_card_view_(nullptr),
+      layout_manager_(nullptr) {
   DCHECK(!instance);
   instance = this;
   WindowManager::Get()->AddObserver(this);
 }
 
 HomeCardImpl::~HomeCardImpl() {
   DCHECK(instance);
   WindowManager::Get()->RemoveObserver(this);
   home_card_widget_->CloseNow();
 
   // Reset the view delegate first as it access search provider during
   // shutdown.
   view_delegate_.reset();
-  instance = NULL;
+  instance = nullptr;
 }
 
 void HomeCardImpl::Init() {
   InstallAccelerators();
   ScreenManager::ContainerParams params("HomeCardContainer", CP_HOME_CARD);
   params.can_activate_children = true;
   aura::Window* container = ScreenManager::Get()->CreateContainer(params);
   layout_manager_ = new HomeCardLayoutManager();
 
   container->SetLayoutManager(layout_manager_);
@@ skipping 17 matching lines @@
   layout_manager_->SetMinimizedLayer(minimized_home_->layer());
 
   SetState(VISIBLE_MINIMIZED);
   home_card_view_->Layout();
 
   AthenaEnv::Get()->SetDisplayWorkAreaInsets(
       gfx::Insets(0, 0, kHomeCardMinimizedHeight, 0));
 }
 
 aura::Window* HomeCardImpl::GetHomeCardWindowForTest() const {
-  return home_card_widget_ ? home_card_widget_->GetNativeWindow() : NULL;
+  return home_card_widget_ ? home_card_widget_->GetNativeWindow() : nullptr;
 }
 
 void HomeCardImpl::InstallAccelerators() {
   const AcceleratorData accelerator_data[] = {
       {TRIGGER_ON_PRESS, ui::VKEY_L, ui::EF_CONTROL_DOWN,
        COMMAND_SHOW_HOME_CARD, AF_NONE},
   };
   AcceleratorManager::Get()->RegisterAccelerators(
       accelerator_data, arraysize(accelerator_data), this);
 }
@@ skipping 128 matching lines @@
                            scoped_ptr<SearchControllerFactory> search_factory) {
   (new HomeCardImpl(model_builder.Pass(), search_factory.Pass()))->Init();
   DCHECK(instance);
   return instance;
 }
 
 // static
 void HomeCard::Shutdown() {
   DCHECK(instance);
   delete instance;
-  instance = NULL;
+  instance = nullptr;
 }
 
 // static
 HomeCard* HomeCard::Get() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena