NULL -> nullptr under athena/

athena/content/app_activity_browsertest.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/activity/public/activity.h"
 #include "athena/resource_manager/public/resource_manager.h"
 #include "athena/test/base/activity_lifetime_tracker.h"
 #include "athena/test/chrome/athena_app_browsertest.h"
 #include "athena/test/chrome/test_util.h"
 #include "athena/wm/public/window_list_provider.h"
@@ skipping 23 matching lines @@
   virtual void TearDownOnMainThread() override {
     tracker_.reset();
     AthenaAppBrowserTest::TearDownOnMainThread();
   }
 
  protected:
   // A |proxy_activity| got deleted and this function waits, using the |tracker|
   // until the application got restarted returning the new application activity.
   Activity* WaitForProxyDestruction(Activity* proxy_activity) {
     ActivityLifetimeTracker tracker;
-    void* deleted_activity = NULL;
-    Activity* app_activity = NULL;
+    void* deleted_activity = nullptr;
+    Activity* app_activity = nullptr;
     while (!app_activity && !deleted_activity) {
       deleted_activity = tracker_->GetDeletedActivityAndReset();
       app_activity = tracker_->GetNewActivityAndReset();
       test_util::WaitUntilIdle();
       usleep(5000);
     }
     EXPECT_EQ(deleted_activity, proxy_activity);
     EXPECT_TRUE(app_activity);
     return app_activity;
   }
 
   // Returns true when the window of the |activity| has the focus.
   bool IsActivityActive(Activity* activity) {
     return wm::IsActiveWindow(activity->GetWindow());
   }
 
   // Create a setup where the frontmost window is a web activity and then
   // an unloaded app activity (proxy). Note that the resource manager will be
   // set to CRITICAL to force the application to unload.
   void SetUpWebAndProxyActivity(Activity** web_activity,
                                 Activity** proxy_activity) {
     // Create an application activity.
     Activity* app_activity = CreateTestAppActivity(GetTestAppID());
     ASSERT_TRUE(app_activity);
     EXPECT_EQ(app_activity, tracker_->GetNewActivityAndReset());
-    EXPECT_EQ(NULL, tracker_->GetDeletedActivityAndReset());
+    EXPECT_EQ(nullptr, tracker_->GetDeletedActivityAndReset());
 
     // Then a web activity (which will then be in front of the app).
     *web_activity = test_util::CreateTestWebActivity(
         test_util::GetBrowserContext(),
         base::UTF8ToUTF16("App1"),
         GURL(kTestUrl));
     ASSERT_TRUE(*web_activity);
     EXPECT_EQ(*web_activity, tracker_->GetNewActivityAndReset());
-    EXPECT_EQ(NULL, tracker_->GetDeletedActivityAndReset());
+    EXPECT_EQ(nullptr, tracker_->GetDeletedActivityAndReset());
 
     const aura::Window::Windows& windows =
         WindowManager::Get()->GetWindowListProvider()->GetWindowList();
 
     // The order of windows should now be: Web activity, app activity.
     EXPECT_EQ(app_activity->GetWindow(), windows[0]);
     EXPECT_EQ((*web_activity)->GetWindow(), windows[1]);
 
     // We let the ResourceManager unload now the app. To accomplish this, we
     // first set the app to INIVSIBLE and then let the ResourceManager unload it
@@ skipping 40 matching lines @@
   EXPECT_TRUE(IsActivityActive(web_activity));
 
   Activity* app_activity = CreateTestAppActivity(GetTestAppID());
   EXPECT_TRUE(IsActivityActive(app_activity));
 }
 
 // Test that setting an application state to UNLOADED a proxy gets created and
 // upon changing it to invisible it gets reloaded it its current list location.
 IN_PROC_BROWSER_TEST_F(AppActivityBrowserTest, UnloadReloadApplicationInPlace) {
   // Set up the experiment.
-  Activity* proxy_activity = NULL;
-  Activity* web_activity = NULL;
+  Activity* proxy_activity = nullptr;
+  Activity* web_activity = nullptr;
   SetUpWebAndProxyActivity(&web_activity, &proxy_activity);
   // By returning to a low memory pressure the application should start again.
   test_util::SendTestMemoryPressureEvent(ResourceManager::MEMORY_PRESSURE_LOW);
   Activity* app_activity = WaitForProxyDestruction(proxy_activity);
-  proxy_activity = NULL;  // The proxy is gone now.
+  proxy_activity = nullptr;  // The proxy is gone now.
 
   // After this, the application should remain at its current location in the
   // stack and the current window should stay active.
   const aura::Window::Windows& windows =
       WindowManager::Get()->GetWindowListProvider()->GetWindowList();
   EXPECT_EQ(app_activity->GetWindow(), windows[0]);
   EXPECT_EQ(web_activity->GetWindow(), windows[1]);
   EXPECT_TRUE(IsActivityActive(web_activity));
 }
 
 // Check that activating an unloaded application will bring it properly to the
 // front of the stack (and activate it).
 IN_PROC_BROWSER_TEST_F(AppActivityBrowserTest, ReloadActivatedApplication) {
   // Set up the experiment.
-  Activity* proxy_activity = NULL;
-  Activity* web_activity = NULL;
+  Activity* proxy_activity = nullptr;
+  Activity* web_activity = nullptr;
   SetUpWebAndProxyActivity(&web_activity, &proxy_activity);
 
   // Activating the proxy should push back the web app, lauch the application,
   // kill the proxy and turn it active.
   proxy_activity->GetWindow()->Show();
   wm::ActivateWindow(proxy_activity->GetWindow());
   const aura::Window::Windows& windows =
       WindowManager::Get()->GetWindowListProvider()->GetWindowList();
   EXPECT_EQ(web_activity->GetWindow(), windows[0]);
 
   Activity* app_activity = WaitForProxyDestruction(proxy_activity);
-  proxy_activity = NULL;  // The proxy is gone now.
+  proxy_activity = nullptr;  // The proxy is gone now.
 
   // After this, the application should remain at its current location in the
   // stack and the activation focus should remain on the current window as well.
   EXPECT_EQ(app_activity->GetWindow(), windows[1]);
   EXPECT_TRUE(IsActivityActive(app_activity));
   EXPECT_EQ(web_activity->GetWindow(), windows[0]);
 }
 
 // Check that moving a proxy window to the front will properly restart the app
 // and activate it.
 IN_PROC_BROWSER_TEST_F(AppActivityBrowserTest, ReloadMovedApplication) {
   // Set up the experiment.
-  Activity* proxy_activity = NULL;
-  Activity* web_activity = NULL;
+  Activity* proxy_activity = nullptr;
+  Activity* web_activity = nullptr;
   SetUpWebAndProxyActivity(&web_activity, &proxy_activity);
   // Moving the window to the front will restart the app.
   WindowManager::Get()->GetWindowListProvider()->StackWindowFrontOf(
       proxy_activity->GetWindow(),
       web_activity->GetWindow());
   const aura::Window::Windows& windows =
       WindowManager::Get()->GetWindowListProvider()->GetWindowList();
   EXPECT_EQ(web_activity->GetWindow(), windows[0]);
 
   Activity* app_activity = WaitForProxyDestruction(proxy_activity);
-  proxy_activity = NULL;  // The proxy is gone now.
+  proxy_activity = nullptr;  // The proxy is gone now.
 
   // After this, the application should remain at its current location in the
   // stack and the activation focus should remain on the current window as well.
   EXPECT_EQ(app_activity->GetWindow(), windows[1]);
   EXPECT_TRUE(IsActivityActive(app_activity));
   EXPECT_EQ(web_activity->GetWindow(), windows[0]);
 }
 
 }  // namespace athena