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

extensions/browser/guest_view/guest_view_manager.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_manager.h"
 
 #include "base/strings/stringprintf.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/guest_view/guest_view_base.h"
 #include "extensions/browser/guest_view/guest_view_manager_factory.h"
 #include "extensions/common/guest_view/guest_view_constants.h"
 #include "net/base/escape.h"
 #include "url/gurl.h"
 
 using content::BrowserContext;
 using content::SiteInstance;
 using content::WebContents;
 
 namespace extensions {
 
 // static
-GuestViewManagerFactory* GuestViewManager::factory_ = NULL;
+GuestViewManagerFactory* GuestViewManager::factory_ = nullptr;
 
 GuestViewManager::GuestViewManager(content::BrowserContext* context)
     : current_instance_id_(0), last_instance_id_removed_(0), context_(context) {
 }
 
 GuestViewManager::~GuestViewManager() {}
 
 // static.
 GuestViewManager* GuestViewManager::FromBrowserContext(
     BrowserContext* context) {
   GuestViewManager* guest_manager =
       static_cast<GuestViewManager*>(context->GetUserData(
           guestview::kGuestViewManagerKeyName));
   if (!guest_manager) {
     if (factory_) {
       guest_manager = factory_->CreateGuestViewManager(context);
     } else {
       guest_manager = new GuestViewManager(context);
     }
     context->SetUserData(guestview::kGuestViewManagerKeyName, guest_manager);
   }
   return guest_manager;
 }
 
 content::WebContents* GuestViewManager::GetGuestByInstanceIDSafely(
     int guest_instance_id,
     int embedder_render_process_id) {
   if (!CanEmbedderAccessInstanceIDMaybeKill(embedder_render_process_id,
                                             guest_instance_id)) {
-    return NULL;
+    return nullptr;
   }
   return GetGuestByInstanceID(guest_instance_id);
 }
 
 void GuestViewManager::AttachGuest(
     int embedder_render_process_id,
     int embedder_routing_id,
     int element_instance_id,
     int guest_instance_id,
     const base::DictionaryValue& attach_params) {
@@ skipping 44 matching lines @@
 
 void GuestViewManager::CreateGuest(const std::string& view_type,
                                    const std::string& embedder_extension_id,
                                    content::WebContents* embedder_web_contents,
                                    const base::DictionaryValue& create_params,
                                    const WebContentsCreatedCallback& callback) {
   int guest_instance_id = GetNextInstanceID();
   GuestViewBase* guest =
       GuestViewBase::Create(context_, guest_instance_id, view_type);
   if (!guest) {
-    callback.Run(NULL);
+    callback.Run(nullptr);
     return;
   }
   guest->Init(
       embedder_extension_id, embedder_web_contents, create_params, callback);
 }
 
 content::WebContents* GuestViewManager::CreateGuestWithWebContentsParams(
     const std::string& view_type,
     const std::string& embedder_extension_id,
     int embedder_render_process_id,
     const content::WebContents::CreateParams& create_params) {
   int guest_instance_id = GetNextInstanceID();
   GuestViewBase* guest =
       GuestViewBase::Create(context_, guest_instance_id, view_type);
   if (!guest)
-    return NULL;
+    return nullptr;
   content::WebContents::CreateParams guest_create_params(create_params);
   guest_create_params.guest_delegate = guest;
   content::WebContents* guest_web_contents =
       WebContents::Create(guest_create_params);
   guest->InitWithWebContents(embedder_extension_id,
                              embedder_render_process_id,
                              guest_web_contents);
   return guest_web_contents;
 }
 
 content::WebContents* GuestViewManager::GetGuestByInstanceID(
     content::WebContents* embedder_web_contents,
     int element_instance_id) {
   int guest_instance_id = GetGuestInstanceIDForElementID(embedder_web_contents,
                                                          element_instance_id);
   if (guest_instance_id == guestview::kInstanceIDNone)
-    return NULL;
+    return nullptr;
 
   return GetGuestByInstanceID(guest_instance_id);
 }
 
 int GuestViewManager::GetGuestInstanceIDForElementID(
     content::WebContents* embedder_web_contents,
     int element_instance_id) {
   GuestInstanceIDMap::iterator iter = instance_id_map_.find(
       ElementInstanceKey(embedder_web_contents, element_instance_id));
   if (iter == instance_id_map_.end())
     return guestview::kInstanceIDNone;
   return iter->second;
 }
 
 SiteInstance* GuestViewManager::GetGuestSiteInstance(
     const GURL& guest_site) {
   for (GuestInstanceMap::const_iterator it =
        guest_web_contents_by_instance_id_.begin();
        it != guest_web_contents_by_instance_id_.end(); ++it) {
     if (it->second->GetSiteInstance()->GetSiteURL() == guest_site)
       return it->second->GetSiteInstance();
   }
-  return NULL;
+  return nullptr;
 }
 
 bool GuestViewManager::ForEachGuest(WebContents* embedder_web_contents,
                                     const GuestCallback& callback) {
   for (GuestInstanceMap::iterator it =
            guest_web_contents_by_instance_id_.begin();
        it != guest_web_contents_by_instance_id_.end(); ++it) {
     WebContents* guest = it->second;
     GuestViewBase* guest_view = GuestViewBase::FromWebContents(guest);
     if (embedder_web_contents != guest_view->embedder_web_contents())
@@ skipping 48 matching lines @@
   } else {
     removed_instance_ids_.insert(guest_instance_id);
   }
 }
 
 content::WebContents* GuestViewManager::GetGuestByInstanceID(
     int guest_instance_id) {
   GuestInstanceMap::const_iterator it =
       guest_web_contents_by_instance_id_.find(guest_instance_id);
   if (it == guest_web_contents_by_instance_id_.end())
-    return NULL;
+    return nullptr;
   return it->second;
 }
 
 bool GuestViewManager::CanEmbedderAccessInstanceIDMaybeKill(
     int embedder_render_process_id,
     int guest_instance_id) {
   if (!CanEmbedderAccessInstanceID(embedder_render_process_id,
                                    guest_instance_id)) {
     // The embedder process is trying to access a guest it does not own.
     content::RecordAction(
@@ skipping 36 matching lines @@
     return true;
 
   GuestViewBase* guest_view = GuestViewBase::FromWebContents(it->second);
   if (!guest_view)
     return false;
 
   return embedder_render_process_id == guest_view->embedder_render_process_id();
 }
 
 }  // namespace extensions