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

extensions/browser/image_loader_unittest.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/image_loader.h"
 
 #include "base/files/file_path.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
@@ skipping 56 matching lines @@
     image_loaded_count_ = 0;
     return result;
   }
 
   scoped_refptr<Extension> CreateExtension(const char* dir_name,
                                            Manifest::Location location) {
     // Create and load an extension.
     base::FilePath extension_dir;
     if (!PathService::Get(DIR_TEST_DATA, &extension_dir)) {
       EXPECT_FALSE(true);
-      return NULL;
+      return nullptr;
     }
     extension_dir = extension_dir.AppendASCII(dir_name);
     int error_code = 0;
     std::string error;
     JSONFileValueSerializer serializer(
         extension_dir.AppendASCII("manifest.json"));
     scoped_ptr<base::DictionaryValue> valid_value(
         static_cast<base::DictionaryValue*>(serializer.Deserialize(&error_code,
                                                                    &error)));
     EXPECT_EQ(0, error_code) << error;
     if (error_code != 0)
-      return NULL;
+      return nullptr;
 
     EXPECT_TRUE(valid_value.get());
     if (!valid_value)
-      return NULL;
+      return nullptr;
 
     return Extension::Create(
         extension_dir, location, *valid_value, Extension::NO_FLAGS, &error);
   }
 
   gfx::Image image_;
   gfx::ImageFamily image_family_;
 
  private:
   virtual void SetUp() OVERRIDE {
     testing::Test::SetUp();
     file_thread_.Start();
     io_thread_.Start();
   }
 
   int image_loaded_count_;
   bool quit_in_image_loaded_;
   base::MessageLoop ui_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
   content::TestBrowserThread io_thread_;
   scoped_ptr<NotificationService> notification_service_;
 };
 
 // Tests loading an image works correctly.
 TEST_F(ImageLoaderTest, LoadImage) {
   scoped_refptr<Extension> extension(
       CreateExtension("image_loader", Manifest::INVALID_LOCATION));
-  ASSERT_TRUE(extension.get() != NULL);
+  ASSERT_TRUE(extension.get() != nullptr);
 
   ExtensionResource image_resource =
       IconsInfo::GetIconResource(extension.get(),
                                  extension_misc::EXTENSION_ICON_SMALLISH,
                                  ExtensionIconSet::MATCH_EXACTLY);
   gfx::Size max_size(extension_misc::EXTENSION_ICON_SMALLISH,
                      extension_misc::EXTENSION_ICON_SMALLISH);
   ImageLoader loader;
   loader.LoadImageAsync(extension.get(),
                         image_resource,
@@ skipping 13 matching lines @@
   // Check that the image was loaded.
   EXPECT_EQ(extension_misc::EXTENSION_ICON_SMALLISH,
             image_.ToSkBitmap()->width());
 }
 
 // Tests deleting an extension while waiting for the image to load doesn't cause
 // problems.
 TEST_F(ImageLoaderTest, DeleteExtensionWhileWaitingForCache) {
   scoped_refptr<Extension> extension(
       CreateExtension("image_loader", Manifest::INVALID_LOCATION));
-  ASSERT_TRUE(extension.get() != NULL);
+  ASSERT_TRUE(extension.get() != nullptr);
 
   ExtensionResource image_resource =
       IconsInfo::GetIconResource(extension.get(),
                                  extension_misc::EXTENSION_ICON_SMALLISH,
                                  ExtensionIconSet::MATCH_EXACTLY);
   gfx::Size max_size(extension_misc::EXTENSION_ICON_SMALLISH,
                      extension_misc::EXTENSION_ICON_SMALLISH);
   ImageLoader loader;
   std::set<int> sizes;
   sizes.insert(extension_misc::EXTENSION_ICON_SMALLISH);
   loader.LoadImageAsync(extension.get(),
                         image_resource,
                         max_size,
                         base::Bind(&ImageLoaderTest::OnImageLoaded,
                                    base::Unretained(this)));
 
   // The image isn't cached, so we should not have received notification.
   EXPECT_EQ(0, image_loaded_count());
 
   // Send out notification the extension was uninstalled.
   UnloadedExtensionInfo details(extension.get(),
                                 UnloadedExtensionInfo::REASON_UNINSTALL);
   content::NotificationService::current()->Notify(
       NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
       content::NotificationService::AllSources(),
       content::Details<UnloadedExtensionInfo>(&details));
 
   // Chuck the extension, that way if anyone tries to access it we should crash
   // or get valgrind errors.
-  extension = NULL;
+  extension = nullptr;
 
   WaitForImageLoad();
 
   // Even though we deleted the extension, we should still get the image.
   // We should still have gotten the image.
   EXPECT_EQ(1, image_loaded_count());
 
   // Check that the image was loaded.
   EXPECT_EQ(extension_misc::EXTENSION_ICON_SMALLISH,
             image_.ToSkBitmap()->width());
 }
 
 // Tests loading multiple dimensions of the same image.
 TEST_F(ImageLoaderTest, MultipleImages) {
   scoped_refptr<Extension> extension(
       CreateExtension("image_loader", Manifest::INVALID_LOCATION));
-  ASSERT_TRUE(extension.get() != NULL);
+  ASSERT_TRUE(extension.get() != nullptr);
 
   std::vector<ImageLoader::ImageRepresentation> info_list;
   int sizes[] = {extension_misc::EXTENSION_ICON_BITTY,
                  extension_misc::EXTENSION_ICON_SMALLISH, };
   for (size_t i = 0; i < arraysize(sizes); ++i) {
     ExtensionResource resource = IconsInfo::GetIconResource(
         extension.get(), sizes[i], ExtensionIconSet::MATCH_EXACTLY);
     info_list.push_back(ImageLoader::ImageRepresentation(
         resource,
         ImageLoader::ImageRepresentation::RESIZE_WHEN_LARGER,
@@ skipping 24 matching lines @@
   EXPECT_EQ(extension_misc::EXTENSION_ICON_BITTY,
             img_rep1->pixel_width());
   EXPECT_EQ(extension_misc::EXTENSION_ICON_SMALLISH,
             img_rep2->pixel_width());
 }
 
 // Tests loading multiple dimensions of the same image into an image family.
 TEST_F(ImageLoaderTest, LoadImageFamily) {
   scoped_refptr<Extension> extension(
       CreateExtension("image_loader", Manifest::INVALID_LOCATION));
-  ASSERT_TRUE(extension.get() != NULL);
+  ASSERT_TRUE(extension.get() != nullptr);
 
   std::vector<ImageLoader::ImageRepresentation> info_list;
   int sizes[] = {extension_misc::EXTENSION_ICON_BITTY,
                  extension_misc::EXTENSION_ICON_SMALLISH, };
   for (size_t i = 0; i < arraysize(sizes); ++i) {
     ExtensionResource resource = IconsInfo::GetIconResource(
         extension.get(), sizes[i], ExtensionIconSet::MATCH_EXACTLY);
     info_list.push_back(ImageLoader::ImageRepresentation(
         resource,
         ImageLoader::ImageRepresentation::NEVER_RESIZE,
@@ skipping 45 matching lines @@
 
   const gfx::ImageSkiaRep* img_rep1 = &image_reps[0];
   const gfx::ImageSkiaRep* img_rep2 = &image_reps[1];
   EXPECT_EQ(extension_misc::EXTENSION_ICON_BITTY, img_rep1->pixel_width());
   EXPECT_EQ(1.0f, img_rep1->scale());
   EXPECT_EQ(extension_misc::EXTENSION_ICON_SMALLISH, img_rep2->pixel_width());
   EXPECT_EQ(2.0f, img_rep2->scale());
 }
 
 }  // namespace extensions