Run clang-modernize -use-nullptr over src/extensions/.

extensions/browser/guest_view/app_view/app_view_guest.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 "extensions/browser/guest_view/app_view/app_view_guest.h"
 
 #include "base/command_line.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/common/renderer_preferences.h"
 #include "extensions/browser/api/app_runtime/app_runtime_api.h"
@@ skipping 74 matching lines @@
 
   response_map->erase(guest_instance_id);
   return true;
 }
 
 // static
 GuestViewBase* AppViewGuest::Create(content::BrowserContext* browser_context,
                                     int guest_instance_id) {
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
       extensions::switches::kEnableAppView)) {
-    return NULL;
+    return nullptr;
   }
   return new AppViewGuest(browser_context, guest_instance_id);
 }
 
 AppViewGuest::AppViewGuest(content::BrowserContext* browser_context,
                            int guest_instance_id)
     : GuestView<AppViewGuest>(browser_context, guest_instance_id),
       app_view_guest_delegate_(
           ExtensionsAPIClient::Get()->CreateAppViewGuestDelegate()),
       weak_ptr_factory_(this) {
 }
 
 AppViewGuest::~AppViewGuest() {
 }
 
 WindowController* AppViewGuest::GetExtensionWindowController() const {
-  return NULL;
+  return nullptr;
 }
 
 content::WebContents* AppViewGuest::GetAssociatedWebContents() const {
   return web_contents();
 }
 
 bool AppViewGuest::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(AppViewGuest, message)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_Request, OnRequest)
@@ skipping 17 matching lines @@
   return IDS_EXTENSION_TASK_MANAGER_APPVIEW_TAG_PREFIX;
 }
 
 void AppViewGuest::CreateWebContents(
     const std::string& embedder_extension_id,
     int embedder_render_process_id,
     const base::DictionaryValue& create_params,
     const WebContentsCreatedCallback& callback) {
   std::string app_id;
   if (!create_params.GetString(appview::kAppID, &app_id)) {
-    callback.Run(NULL);
+    callback.Run(nullptr);
     return;
   }
 
-  const base::DictionaryValue* data = NULL;
+  const base::DictionaryValue* data = nullptr;
   if (!create_params.GetDictionary(appview::kData, &data)) {
-    callback.Run(NULL);
+    callback.Run(nullptr);
     return;
   }
 
   const ExtensionSet& enabled_extensions =
       ExtensionRegistry::Get(browser_context())->enabled_extensions();
   const Extension* guest_extension = enabled_extensions.GetByID(app_id);
   const Extension* embedder_extension =
       enabled_extensions.GetByID(embedder_extension_id);
 
   if (!guest_extension || !guest_extension->is_platform_app() ||
       !embedder_extension | !embedder_extension->is_platform_app()) {
-    callback.Run(NULL);
+    callback.Run(nullptr);
     return;
   }
 
   pending_response_map.Get().insert(
       std::make_pair(guest_instance_id(),
                      make_linked_ptr(new ResponseInfo(
                                         guest_extension,
                                         weak_ptr_factory_.GetWeakPtr(),
                                         callback))));
 
@@ skipping 35 matching lines @@
 void AppViewGuest::OnRequest(const ExtensionHostMsg_Request_Params& params) {
   extension_function_dispatcher_->Dispatch(params,
                                            web_contents()->GetRenderViewHost());
 }
 
 void AppViewGuest::CompleteCreateWebContents(
     const GURL& url,
     const Extension* guest_extension,
     const WebContentsCreatedCallback& callback) {
   if (!url.is_valid()) {
-    callback.Run(NULL);
+    callback.Run(nullptr);
     return;
   }
   url_ = url;
   guest_extension_id_ = guest_extension->id();
 
   WebContents::CreateParams params(
       browser_context(),
       content::SiteInstance::CreateForURL(browser_context(),
                                           guest_extension->url()));
   params.guest_delegate = this;
   callback.Run(WebContents::Create(params));
 }
 
 void AppViewGuest::LaunchAppAndFireEvent(
     scoped_ptr<base::DictionaryValue> data,
     const WebContentsCreatedCallback& callback,
     ExtensionHost* extension_host) {
   ExtensionSystem* system = ExtensionSystem::Get(browser_context());
   bool has_event_listener = system->event_router()->ExtensionHasEventListener(
       extension_host->extension()->id(),
       app_runtime::OnEmbedRequested::kEventName);
   if (!has_event_listener) {
-    callback.Run(NULL);
+    callback.Run(nullptr);
     return;
   }
 
   scoped_ptr<base::DictionaryValue> embed_request(new base::DictionaryValue());
   embed_request->SetInteger(appview::kGuestInstanceID, guest_instance_id());
   embed_request->SetString(appview::kEmbedderID, embedder_extension_id());
   embed_request->Set(appview::kData, data.release());
   AppRuntimeEventRouter::DispatchOnEmbedRequestedEvent(
       browser_context(), embed_request.Pass(), extension_host->extension());
 }
 
 }  // namespace extensions