NULL -> nullptr under athena/

athena/wm/window_overview_mode.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_overview_mode.h"
 
 #include <complex>
 #include <vector>
 
 #include "athena/wm/overview_toolbar.h"
@@ skipping 36 matching lines @@
   // |split| is set if this window is one of the two split windows in split-view
   // mode.
   bool split;
 };
 
 }  // namespace
 
 DECLARE_WINDOW_PROPERTY_TYPE(WindowOverviewState*);
 DEFINE_OWNED_WINDOW_PROPERTY_KEY(WindowOverviewState,
                                  kWindowOverviewState,
-                                 NULL);
+                                 nullptr);
 
 namespace athena {
 
 namespace {
 
 const float kOverviewDefaultScale = 0.75f;
 
 gfx::Transform GetTransformForSplitWindow(aura::Window* window, float scale) {
   const float kScrollWindowPositionInOverview = 0.65f;
   int x_translate = window->bounds().width() * (1 - scale) / 2;
@@ skipping 222 matching lines @@
                          SplitViewController* split_view_controller,
                          WindowOverviewModeDelegate* delegate)
       : container_(container),
         window_list_provider_(window_list_provider),
         split_view_controller_(split_view_controller),
         delegate_(delegate),
         scoped_targeter_(new aura::ScopedWindowTargeter(
             container,
             scoped_ptr<ui::EventTargeter>(
                 new StaticWindowTargeter(container)))),
-        dragged_window_(NULL) {
+        dragged_window_(nullptr) {
     CHECK(delegate_);
     container_->set_target_handler(this);
 
     // Prepare the desired transforms for all the windows, and set the initial
     // state on the windows.
     ComputeTerminalStatesForAllWindows();
     SetInitialWindowStates();
 
     window_list_provider_->AddObserver(this);
   }
@@ skipping 107 matching lines @@
   aura::Window* SelectWindowAt(ui::LocatedEvent* event) {
     CHECK_EQ(container_, event->target());
     // Find the old targeter to find the target of the event.
     ui::EventTarget* window = container_;
     ui::EventTargeter* targeter = scoped_targeter_->old_targeter();
     while (!targeter && window->GetParentTarget()) {
       window = window->GetParentTarget();
       targeter = window->GetEventTargeter();
     }
     if (!targeter)
-      return NULL;
+      return nullptr;
     aura::Window* target = static_cast<aura::Window*>(
         targeter->FindTargetForLocatedEvent(container_, event));
     while (target && target->parent() != container_)
       target = target->parent();
     aura::Window* transient_parent =
-        target ? wm::GetTransientParent(target) : NULL;
+        target ? wm::GetTransientParent(target) : nullptr;
     return transient_parent ? transient_parent : target;
   }
 
   // Scroll the window list by |delta_y| amount. |delta_y| is negative when
   // scrolling up; and positive when scrolling down.
   void DoScroll(float delta_y) {
     const float kEpsilon = 1e-3f;
     float delta_y_p = std::abs(delta_y) / GetScrollableHeight();
     const aura::Window::Windows& windows =
         window_list_provider_->GetWindowList();
@@ skipping 56 matching lines @@
   }
 
   void RemoveAnimationObserver() {
     ui::Compositor* compositor = container_->GetHost()->compositor();
     if (compositor->HasAnimationObserver(this))
       compositor->RemoveAnimationObserver(this);
   }
 
   aura::Window* GetSplitWindowDropTarget(const ui::GestureEvent& event) const {
     if (!split_view_controller_->IsSplitViewModeActive())
-      return NULL;
+      return nullptr;
     CHECK(dragged_window_);
     CHECK_NE(split_view_controller_->left_window(), dragged_window_);
     CHECK_NE(split_view_controller_->right_window(), dragged_window_);
     aura::Window* window = split_view_controller_->left_window();
     if (GetTransformedBounds(window).Contains(event.location()))
       return window;
     window = split_view_controller_->right_window();
     if (GetTransformedBounds(window).Contains(event.location()))
       return window;
-    return NULL;
+    return nullptr;
   }
 
   void DragWindow(const ui::GestureEvent& event) {
     CHECK(dragged_window_);
     CHECK_EQ(ui::ET_GESTURE_SCROLL_UPDATE, event.type());
     CHECK(overview_toolbar_);
     gfx::Vector2dF dragged_distance =
         dragged_start_location_ - event.location();
     WindowOverviewState* dragged_state =
         dragged_window_->GetProperty(kWindowOverviewState);
@@ skipping 92 matching lines @@
       float transform_x = 0.f;
       if (gesture.location().x() > dragged_start_location_.x())
         transform_x = container_->bounds().right() - transformed_bounds.x();
       else
         transform_x = -(transformed_bounds.x() + transformed_bounds.width());
       transform.Translate(transform_x / kOverviewDefaultScale, 0);
 
       setter.SetOpacity(kMinOpacity);
     }
     delete dragged_window_;
-    dragged_window_ = NULL;
+    dragged_window_ = nullptr;
   }
 
   void RestoreDragWindow() {
     CHECK(dragged_window_);
     WindowOverviewState* dragged_state =
         dragged_window_->GetProperty(kWindowOverviewState);
     CHECK(dragged_state);
 
     AnimateTransientGroupSetter setter(dragged_window_);
     setter.SetTransform(GetTransformForState(dragged_window_, dragged_state));
     setter.SetOpacity(1.0f);
-    dragged_window_ = NULL;
+    dragged_window_ = nullptr;
   }
 
   void EndDragWindow(const ui::GestureEvent& gesture) {
     CHECK(dragged_window_);
     CHECK(overview_toolbar_);
     OverviewToolbar::ActionType action = overview_toolbar_->current_action();
     overview_toolbar_.reset();
     if (action == OverviewToolbar::ACTION_TYPE_SPLIT) {
-      delegate_->OnSelectSplitViewWindow(NULL,
-                                         dragged_window_,
-                                         dragged_window_);
+      delegate_->OnSelectSplitViewWindow(
+          nullptr, dragged_window_, dragged_window_);
       return;
     }
 
     // If the window is dropped on one of the left/right windows in split-mode,
     // then switch that window.
     aura::Window* split_drop = GetSplitWindowDropTarget(gesture);
     if (split_drop) {
       aura::Window* left = split_view_controller_->left_window();
       aura::Window* right = split_view_controller_->right_window();
       if (left == split_drop)
@@ skipping 58 matching lines @@
           std::abs(gesture->details().scroll_y_hint()) * 2) {
         dragged_start_location_ = gesture->location();
         dragged_window_ = SelectWindowAt(gesture);
         if (split_view_controller_->IsSplitViewModeActive() &&
             (dragged_window_ == split_view_controller_->left_window() ||
              dragged_window_ == split_view_controller_->right_window())) {
           // TODO(sad): Allow closing the left/right window. Closing one of
           // these windows will terminate the split-view mode. Until then, do
           // not allow closing these (since otherwise it gets into an undefined
           // state).
-          dragged_window_ = NULL;
+          dragged_window_ = nullptr;
         }
 
         if (dragged_window_) {
           // Show the toolbar (for closing a window, or going into split-view
           // mode). If already in split-view mode, then do not show the 'Split'
           // option.
           overview_toolbar_.reset(new OverviewToolbar(container_));
           if (!split_view_controller_->CanActivateSplitViewMode()) {
             overview_toolbar_->DisableAction(
                 OverviewToolbar::ACTION_TYPE_SPLIT);
@@ skipping 17 matching lines @@
         CreateFlingerFor(*gesture);
         AddAnimationObserver();
       }
       gesture->SetHandled();
     } else if (gesture->type() == ui::ET_GESTURE_TAP_DOWN) {
       if (fling_) {
         fling_.reset();
         RemoveAnimationObserver();
         gesture->SetHandled();
       }
-      dragged_window_ = NULL;
+      dragged_window_ = nullptr;
     }
   }
 
   // ui::CompositorAnimationObserver:
   virtual void OnAnimationStep(base::TimeTicks timestamp) override {
     CHECK(fling_);
     gfx::Vector2dF delta;
     bool fling_active = fling_->ComputeScrollDeltaAtTime(timestamp, &delta);
 
     if (!delta.IsZero())
@@ skipping 74 matching lines @@
     aura::Window* container,
     WindowListProvider* window_list_provider,
     SplitViewController* split_view_controller,
     WindowOverviewModeDelegate* delegate) {
   return scoped_ptr<WindowOverviewMode>(
       new WindowOverviewModeImpl(container, window_list_provider,
                                  split_view_controller, delegate));
 }
 
 }  // namespace athena