NULL -> nullptr under athena/

athena/wm/split_view_controller.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/split_view_controller.h"
 
 #include <cmath>
 
 #include "athena/screen/public/screen_manager.h"
 #include "athena/wm/public/window_list_provider.h"
@@ skipping 115 matching lines @@
       return window_;
     }
 
     return WindowTargeter::FindTargetForLocatedEvent(root, event);
   }
 
   // aura::WindowObserver:
   virtual void OnWindowDestroying(aura::Window* window) override {
     DCHECK_EQ(window, window_);
     window_->RemoveObserver(this);
-    window_ = NULL;
+    window_ = nullptr;
   }
 
   // Minimum dimension of a target to be comfortably touchable.
   // The effective touch target area of |priority_window_| gets expanded so
   // that it's width and height is ayt least |kMinTouchDimension|.
   int const kMinTouchDimension = 26;
 
   aura::Window* window_;
   views::View* priority_view_;
 
@@ skipping 16 matching lines @@
 }
 
 }  // namespace
 
 SplitViewController::SplitViewController(
     aura::Window* container,
     WindowListProvider* window_list_provider)
     : state_(INACTIVE),
       container_(container),
       window_list_provider_(window_list_provider),
-      left_window_(NULL),
-      right_window_(NULL),
+      left_window_(nullptr),
+      right_window_(nullptr),
       divider_position_(0),
       divider_scroll_start_position_(0),
-      divider_widget_(NULL),
-      drag_handle_(NULL),
+      divider_widget_(nullptr),
+      drag_handle_(nullptr),
       weak_factory_(this) {
 }
 
 SplitViewController::~SplitViewController() {
 }
 
 bool SplitViewController::CanActivateSplitViewMode() const {
   // TODO(mfomitchev): return false in full screen.
   return (!IsSplitViewModeActive() &&
               window_list_provider_->GetWindowList().size() >= 2 &&
@@ skipping 68 matching lines @@
 }
 
 void SplitViewController::ReplaceWindow(aura::Window* window,
                                         aura::Window* replace_with) {
   CHECK(IsSplitViewModeActive());
   CHECK(replace_with);
   CHECK(window == left_window_ || window == right_window_);
   CHECK(replace_with != left_window_ && replace_with != right_window_);
   DCHECK(window_list_provider_->IsWindowInList(replace_with));
 
-  aura::Window* not_replaced = NULL;
+  aura::Window* not_replaced = nullptr;
   if (window == left_window_) {
     left_window_ = replace_with;
     not_replaced = right_window_;
   } else {
     right_window_ = replace_with;
     not_replaced = left_window_;
   }
   UpdateLayout(false);
 
   wm::ActivateWindow(replace_with);
   window_list_provider_->StackWindowBehindTo(not_replaced, replace_with);
 
   window->SetTransform(gfx::Transform());
   window->Hide();
 }
 
 void SplitViewController::DeactivateSplitMode() {
   CHECK_EQ(ACTIVE, state_);
   SetState(INACTIVE);
   UpdateLayout(false);
-  left_window_ = right_window_ = NULL;
+  left_window_ = right_window_ = nullptr;
 }
 
 void SplitViewController::InitializeDivider() {
   CHECK(!divider_widget_);
   CHECK(!drag_handle_);
 
   drag_handle_ = CreateDragHandleView(DRAG_HANDLE_HORIZONTAL,
                                       this,
                                       kDragHandleWidth,
                                       kDragHandleHeight);
@@ skipping 67 matching lines @@
   return gfx::Rect(divider_position_ + kDividerWidth / 2,
                    0,
                    container_width - divider_position_ - kDividerWidth / 2,
                    work_area.height());
 }
 
 void SplitViewController::SetState(SplitViewController::State state) {
   if (state_ == state)
     return;
 
-  if (divider_widget_ == NULL)
+  if (divider_widget_ == nullptr)
     InitializeDivider();
 
   state_ = state;
 
   ScreenManager::Get()->SetRotationLocked(state_ != INACTIVE);
   if (state == INACTIVE)
     HideDivider();
   else
     ShowDivider();
 }
@@ skipping 60 matching lines @@
     if (right_window_->bounds().width() >= right_area_bounds.width()) {
       right_transform.Translate(
           right_area_bounds.x() - right_window_->bounds().x(), 0);
     } else {
       right_transform =
           GetTransformForBounds(right_window_->bounds(), right_area_bounds);
     }
     SetWindowTransforms(
         left_transform, right_transform, divider_transform, animate);
   }
-  // Note: |left_window_| and |right_window_| may be NULL if calling
+  // Note: |left_window_| and |right_window_| may be nullptr if calling
   // SetWindowTransforms():
   // - caused the in-progress animation to abort.
   // - started a zero duration animation.
 }
 
 void SplitViewController::SetWindowTransforms(
     const gfx::Transform& left_transform,
     const gfx::Transform& right_transform,
     const gfx::Transform& divider_transform,
     bool animate) {
@@ skipping 20 matching lines @@
     right_window_->SetTransform(right_transform);
   } else {
     left_window_->SetTransform(left_transform);
     divider_widget_->GetNativeWindow()->SetTransform(divider_transform);
     right_window_->SetTransform(right_transform);
   }
 }
 
 void SplitViewController::OnAnimationCompleted() {
   // Animation can be cancelled when deactivated.
-  if (left_window_ == NULL)
+  if (left_window_ == nullptr)
     return;
   UpdateLayout(false);
 
   for (size_t i = 0; i < to_hide_.size(); ++i)
     to_hide_[i]->Hide();
   to_hide_.clear();
 
   if (state_ == INACTIVE) {
-    left_window_ = NULL;
-    right_window_ = NULL;
+    left_window_ = nullptr;
+    right_window_ = nullptr;
   }
 }
 
 int SplitViewController::GetDefaultDividerPosition() {
   return container_->GetBoundsInScreen().width() / 2;
 }
 
 float SplitViewController::GetMaxDistanceFromMiddleForTest() const {
   return kMaxDistanceFromMiddle;
 }
@@ skipping 115 matching lines @@
     ShowDivider();
 }
 
 void SplitViewController::OnSplitViewModeEnter() {
 }
 
 void SplitViewController::OnSplitViewModeExit() {
 }
 
 }  // namespace athena