NULL -> nullptr under athena/

athena/wm/window_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/wm/window_manager_impl.h"
 
 #include <algorithm>
 
 #include "athena/screen/public/screen_manager.h"
 #include "athena/util/container_priorities.h"
@@ skipping 13 matching lines @@
 #include "ui/gfx/screen.h"
 #include "ui/wm/core/shadow_controller.h"
 #include "ui/wm/core/transient_window_manager.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/core/wm_state.h"
 #include "ui/wm/public/activation_client.h"
 #include "ui/wm/public/window_types.h"
 
 namespace athena {
 namespace {
-class WindowManagerImpl* instance = NULL;
+class WindowManagerImpl* instance = nullptr;
 
 void SetWindowState(aura::Window* window,
                     const gfx::Rect& bounds,
                     const gfx::Transform& transform) {
   window->SetBounds(bounds);
   window->SetTransform(transform);
 }
 
 }  // namespace
 
@@ skipping 133 matching lines @@
   RemoveObserver(split_view_controller_.get());
   split_view_controller_.reset();
   window_list_provider_.reset();
   if (container_) {
     container_->RemoveObserver(this);
     container_->RemovePreTargetHandler(bezel_controller_.get());
   }
   // |title_drag_controller_| needs to be reset before |container_|.
   title_drag_controller_.reset();
   container_.reset();
-  instance = NULL;
+  instance = nullptr;
 }
 
 void WindowManagerImpl::ToggleSplitView() {
   if (IsOverviewModeActive())
     return;
 
   if (split_view_controller_->IsSplitViewModeActive()) {
     split_view_controller_->DeactivateSplitMode();
     FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnSplitViewModeExit());
     // Relayout so that windows are maximzied.
     container_->layout_manager()->OnWindowResized();
   } else if (split_view_controller_->CanActivateSplitViewMode()) {
     FOR_EACH_OBSERVER(WindowManagerObserver,
                       observers_,
                       OnSplitViewModeEnter());
-    split_view_controller_->ActivateSplitMode(NULL, NULL, NULL);
+    split_view_controller_->ActivateSplitMode(nullptr, nullptr, nullptr);
   }
 }
 
 void WindowManagerImpl::EnterOverview() {
   if (IsOverviewModeActive())
     return;
 
-  bezel_controller_->set_left_right_delegate(NULL);
+  bezel_controller_->set_left_right_delegate(nullptr);
   FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnOverviewModeEnter());
 
   // Note: The window_list_provider_ resembles the exact window list of the
   // container, so no re-stacking is required before showing the OverviewMode.
   overview_ = WindowOverviewMode::Create(
       container_.get(), window_list_provider_.get(),
       split_view_controller_.get(), this);
   AcceleratorManager::Get()->RegisterAccelerator(kEscAcceleratorData, this);
 }
 
@@ skipping 140 matching lines @@
   }
   return true;
 }
 
 aura::Window* WindowManagerImpl::GetWindowBehind(aura::Window* window) {
   const aura::Window::Windows& windows = window_list_provider_->GetWindowList();
   aura::Window::Windows::const_reverse_iterator iter =
       std::find(windows.rbegin(), windows.rend(), window);
   CHECK(iter != windows.rend());
   ++iter;
-  aura::Window* behind = NULL;
+  aura::Window* behind = nullptr;
   if (iter != windows.rend())
     behind = *iter++;
 
   if (split_view_controller_->IsSplitViewModeActive()) {
     aura::Window* left = split_view_controller_->left_window();
     aura::Window* right = split_view_controller_->right_window();
     CHECK(window == left || window == right);
     if (behind == left || behind == right)
-      behind = (iter == windows.rend()) ? NULL : *iter;
+      behind = (iter == windows.rend()) ? nullptr : *iter;
   }
 
   return behind;
 }
 
 void WindowManagerImpl::OnTitleDragStarted(aura::Window* window) {
   aura::Window* next_window = GetWindowBehind(window);
   if (!next_window)
     return;
   // Make sure |window| is active.
@@ skipping 64 matching lines @@
   DCHECK(!instance);
 }
 
 // static
 WindowManager* WindowManager::Get() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena