NULL -> nullptr under athena/

athena/content/web_activity.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/content/web_activity.h"
 
 #include "athena/activity/public/activity_factory.h"
 #include "athena/activity/public/activity_manager.h"
 #include "athena/content/content_proxy.h"
 #include "athena/content/media_utils.h"
@@ skipping 247 matching lines @@
       case NEW_POPUP:
       case NEW_WINDOW: {
         Activity* activity = ActivityFactory::Get()->CreateWebActivity(
             browser_context(), base::string16(), params.url);
         Activity::Show(activity);
         break;
       }
       default:
         break;
     }
-    // NULL is returned if the URL wasn't opened immediately.
-    return NULL;
+    // nullptr is returned if the URL wasn't opened immediately.
+    return nullptr;
   }
 
   virtual bool CanOverscrollContent() const override {
     const std::string value = CommandLine::ForCurrentProcess()->
         GetSwitchValueASCII(switches::kOverscrollHistoryNavigation);
     return value != "0";
   }
 
   virtual void OverscrollUpdate(float delta_y) override {
     overscroll_y_ = delta_y;
@@ skipping 51 matching lines @@
     GetWidget()->SetFullscreen(fullscreen_);
   }
 
   virtual bool IsFullscreenForTabOrPending(
       const content::WebContents* web_contents) const override {
     return fullscreen_;
   }
 
   virtual void LoadingStateChanged(content::WebContents* source,
                                    bool to_different_document) override {
-    bool has_stopped = source == NULL || !source->IsLoading();
+    bool has_stopped = source == nullptr || !source->IsLoading();
     LoadProgressChanged(source, has_stopped ? 1 : 0);
   }
 
   virtual void LoadProgressChanged(content::WebContents* source,
                                    double progress) override {
     if (!progress)
       return;
 
     if (!progress_bar_) {
       CreateProgressBar();
       source->GetNativeView()->layer()->Add(progress_bar_.get());
     }
     progress_bar_->SetBounds(gfx::Rect(
         0, 0, progress * progress_bar_->parent()->bounds().width(), 3));
     if (progress < 1)
       return;
 
     ui::ScopedLayerAnimationSettings settings(progress_bar_->GetAnimator());
     settings.SetTweenType(gfx::Tween::EASE_IN);
     ui::Layer* layer = progress_bar_.get();
     settings.AddObserver(new ui::ClosureAnimationObserver(
         base::Bind(&base::DeletePointer<ui::Layer>, progress_bar_.release())));
     layer->SetOpacity(0.f);
   }
 
   virtual content::JavaScriptDialogManager* GetJavaScriptDialogManager()
       override {
     NOTIMPLEMENTED();
-    return NULL;
+    return nullptr;
   }
 
   virtual content::ColorChooser* OpenColorChooser(
       content::WebContents* web_contents,
       SkColor color,
       const std::vector<content::ColorSuggestion>& suggestions) override {
     return athena::OpenColorChooser(web_contents, color, suggestions);
   }
 
   // Called when a file selection is to be done.
@@ skipping 117 matching lines @@
       break;
     case ACTIVITY_PERSISTENT:
       DCHECK_EQ(ACTIVITY_BACKGROUND_LOW_PRIORITY, current_state_);
       // TODO(skuhne): Do this. As soon as the new resource management is
       // agreed upon - or remove otherwise.
       break;
     case ACTIVITY_UNLOADED:
       DCHECK_NE(ACTIVITY_UNLOADED, current_state_);
       if (content_proxy_)
         content_proxy_->ContentWillUnload();
-      Observe(NULL);
+      Observe(nullptr);
       web_view_->EvictContent();
       break;
   }
   // Remember the last requested state.
   current_state_ = state;
 }
 
 Activity::ActivityState WebActivity::GetCurrentState() {
   // If the content is evicted, the state has to be UNLOADED.
   DCHECK(!web_view_->IsContentEvicted() ||
@@ skipping 42 matching lines @@
 
 bool WebActivity::UsesFrame() const {
   return true;
 }
 
 views::View* WebActivity::GetContentsView() {
   return web_view_;
 }
 
 views::Widget* WebActivity::CreateWidget() {
-  return NULL;  // Use default widget.
+  return nullptr;  // Use default widget.
 }
 
 gfx::ImageSkia WebActivity::GetOverviewModeImage() {
   if (content_proxy_.get())
     return content_proxy_->GetContentImage();
   return gfx::ImageSkia();
 }
 
 void WebActivity::PrepareContentsForOverview() {
   // Turn on fast resizing to avoid re-laying out the web contents when
@@ skipping 45 matching lines @@
   }
 }
 
 void WebActivity::OnDidDownloadFavicon(
     int id,
     int http_status_code,
     const GURL& url,
     const std::vector<SkBitmap>& bitmaps,
     const std::vector<gfx::Size>& original_bitmap_sizes) {
   icon_ = CreateFaviconImageSkia(
-      bitmaps, original_bitmap_sizes, kIconSize, NULL);
+      bitmaps, original_bitmap_sizes, kIconSize, nullptr);
   ActivityManager::Get()->UpdateActivity(this);
 }
 
 void WebActivity::DidChangeThemeColor(SkColor theme_color) {
   title_color_ = theme_color;
   ActivityManager::Get()->UpdateActivity(this);
 }
 
 void WebActivity::HideContentProxy() {
   if (content_proxy_.get())
-    content_proxy_.reset(NULL);
+    content_proxy_.reset(nullptr);
 }
 
 void WebActivity::ShowContentProxy() {
   if (!content_proxy_.get())
     content_proxy_.reset(new ContentProxy(web_view_));
 }
 
 }  // namespace athena