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

extensions/browser/guest_view/guest_view_base.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/guest_view_base.h"
 
 #include "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
@@ skipping 73 matching lines @@
   }
 
  private:
   bool destroyed_;
   GuestViewBase* guest_;
 
   void Destroy() {
     if (destroyed_)
       return;
     destroyed_ = true;
-    guest_->embedder_web_contents_ = NULL;
+    guest_->embedder_web_contents_ = nullptr;
     guest_->EmbedderDestroyed();
     guest_->Destroy();
   }
 
   DISALLOW_COPY_AND_ASSIGN(EmbedderWebContentsObserver);
 };
 
 GuestViewBase::GuestViewBase(content::BrowserContext* browser_context,
                              int guest_instance_id)
-    : embedder_web_contents_(NULL),
+    : embedder_web_contents_(nullptr),
       embedder_render_process_id_(0),
       browser_context_(browser_context),
       guest_instance_id_(guest_instance_id),
       view_instance_id_(guestview::kInstanceIDNone),
       element_instance_id_(guestview::kInstanceIDNone),
       initialized_(false),
       auto_size_enabled_(false),
       weak_ptr_factory_(this) {
 }
 
@@ skipping 23 matching lines @@
 
   Feature::Availability availability = feature->IsAvailableToContext(
       embedder_extension,
       process_map->GetMostLikelyContextType(embedder_extension,
                                             embedder_process_id),
       embedder_web_contents->GetLastCommittedURL());
   if (!availability.is_available()) {
     // The derived class did not create a WebContents so this class serves no
     // purpose. Let's self-destruct.
     delete this;
-    callback.Run(NULL);
+    callback.Run(nullptr);
     return;
   }
 
   CreateWebContents(embedder_extension_id,
                     embedder_process_id,
                     create_params,
                     base::Bind(&GuestViewBase::CompleteInit,
                                AsWeakPtr(),
                                embedder_extension_id,
                                embedder_process_id,
@@ skipping 66 matching lines @@
     content::BrowserContext* browser_context,
     int guest_instance_id,
     const std::string& view_type) {
   if (guest_view_registry.Get().empty())
     RegisterGuestViewTypes();
 
   GuestViewCreationMap::iterator it =
       guest_view_registry.Get().find(view_type);
   if (it == guest_view_registry.Get().end()) {
     NOTREACHED();
-    return NULL;
+    return nullptr;
   }
   return it->second.Run(browser_context, guest_instance_id);
 }
 
 // static
 GuestViewBase* GuestViewBase::FromWebContents(WebContents* web_contents) {
   WebContentsGuestViewMap* guest_map = webcontents_guestview_map.Pointer();
   WebContentsGuestViewMap::iterator it = guest_map->find(web_contents);
-  return it == guest_map->end() ? NULL : it->second;
+  return it == guest_map->end() ? nullptr : it->second;
 }
 
 // static
 GuestViewBase* GuestViewBase::From(int embedder_process_id,
                                    int guest_instance_id) {
   content::RenderProcessHost* host =
       content::RenderProcessHost::FromID(embedder_process_id);
   if (!host)
-    return NULL;
+    return nullptr;
 
   content::WebContents* guest_web_contents =
       GuestViewManager::FromBrowserContext(host->GetBrowserContext())->
           GetGuestByInstanceIDSafely(guest_instance_id, embedder_process_id);
   if (!guest_web_contents)
-    return NULL;
+    return nullptr;
 
   return GuestViewBase::FromWebContents(guest_web_contents);
 }
 
 // static
 bool GuestViewBase::IsGuest(WebContents* web_contents) {
   return !!GuestViewBase::FromWebContents(web_contents);
 }
 
 base::WeakPtr<GuestViewBase> GuestViewBase::AsWeakPtr() {
@@ skipping 201 matching lines @@
 }
 
 void GuestViewBase::CompleteInit(const std::string& embedder_extension_id,
                                  int embedder_render_process_id,
                                  const WebContentsCreatedCallback& callback,
                                  content::WebContents* guest_web_contents) {
   if (!guest_web_contents) {
     // The derived class did not create a WebContents so this class serves no
     // purpose. Let's self-destruct.
     delete this;
-    callback.Run(NULL);
+    callback.Run(nullptr);
     return;
   }
   InitWithWebContents(embedder_extension_id,
                       embedder_render_process_id,
                       guest_web_contents);
   callback.Run(guest_web_contents);
 }
 
 // static
 void GuestViewBase::RegisterGuestViewTypes() {
   AppViewGuest::Register();
   ExtensionOptionsGuest::Register();
   MimeHandlerViewGuest::Register();
   WebViewGuest::Register();
 }
 
 }  // namespace extensions