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

extensions/browser/extension_icon_image_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/extension_icon_image.h"
 
 #include <vector>
 
 #include "base/json/json_file_value_serializer.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 127 matching lines @@
     image_loaded_count_ = 0;
     return result;
   }
 
   scoped_refptr<Extension> CreateExtension(const char* name,
                                            Manifest::Location location) {
     // Create and load an extension.
     base::FilePath test_file;
     if (!PathService::Get(DIR_TEST_DATA, &test_file)) {
       EXPECT_FALSE(true);
-      return NULL;
+      return nullptr;
     }
     test_file = test_file.AppendASCII(name);
     int error_code = 0;
     std::string error;
     JSONFileValueSerializer serializer(test_file.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(test_file, location, *valid_value,
                              Extension::NO_FLAGS, &error);
   }
 
   // testing::Test overrides:
   virtual void SetUp() OVERRIDE {
     file_thread_.Start();
     io_thread_.Start();
   }
@@ skipping 32 matching lines @@
 
 }  // namespace
 
 TEST_F(ExtensionIconImageTest, Basic) {
   std::vector<ui::ScaleFactor> supported_factors;
   supported_factors.push_back(ui::SCALE_FACTOR_100P);
   supported_factors.push_back(ui::SCALE_FACTOR_200P);
   ui::test::ScopedSetSupportedScaleFactors scoped_supported(supported_factors);
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Manifest::INVALID_LOCATION));
-  ASSERT_TRUE(extension.get() != NULL);
+  ASSERT_TRUE(extension.get() != nullptr);
 
   gfx::ImageSkia default_icon = GetDefaultIcon();
 
   // Load images we expect to find as representations in icon_image, so we
   // can later use them to validate icon_image.
   SkBitmap bitmap_16 = GetTestBitmap(extension.get(), "16.png", 16);
   ASSERT_FALSE(bitmap_16.empty());
 
   // There is no image of size 32 defined in the extension manifest, so we
   // should expect manifest image of size 48 resized to size 32.
@@ skipping 52 matching lines @@
 
 // There is no resource with either exact or bigger size, but there is a smaller
 // resource.
 TEST_F(ExtensionIconImageTest, FallbackToSmallerWhenNoBigger) {
   std::vector<ui::ScaleFactor> supported_factors;
   supported_factors.push_back(ui::SCALE_FACTOR_100P);
   supported_factors.push_back(ui::SCALE_FACTOR_200P);
   ui::test::ScopedSetSupportedScaleFactors scoped_supported(supported_factors);
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Manifest::INVALID_LOCATION));
-  ASSERT_TRUE(extension.get() != NULL);
+  ASSERT_TRUE(extension.get() != nullptr);
 
   gfx::ImageSkia default_icon = GetDefaultIcon();
 
   // Load images we expect to find as representations in icon_image, so we
   // can later use them to validate icon_image.
   SkBitmap bitmap_48 = GetTestBitmap(extension.get(), "48.png", 48);
   ASSERT_FALSE(bitmap_48.empty());
 
   IconImage image(browser_context(),
                   extension.get(),
@@ skipping 16 matching lines @@
   EXPECT_EQ(64, representation.pixel_width());
   EXPECT_TRUE(gfx::BitmapsAreEqual(representation.sk_bitmap(),
                                    EnsureBitmapSize(bitmap_48, 64)));
 }
 
 // There is no resource with exact size, but there is a smaller and a bigger
 // one. The bigger resource should be loaded.
 TEST_F(ExtensionIconImageTest, FallbackToBigger) {
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Manifest::INVALID_LOCATION));
-  ASSERT_TRUE(extension.get() != NULL);
+  ASSERT_TRUE(extension.get() != nullptr);
 
   gfx::ImageSkia default_icon = GetDefaultIcon();
 
   // Load images we expect to find as representations in icon_image, so we
   // can later use them to validate icon_image.
   SkBitmap bitmap_24 = GetTestBitmap(extension.get(), "24.png", 24);
   ASSERT_FALSE(bitmap_24.empty());
 
   IconImage image(browser_context(),
                   extension.get(),
@@ skipping 15 matching lines @@
   EXPECT_EQ(17, representation.pixel_width());
   EXPECT_TRUE(gfx::BitmapsAreEqual(representation.sk_bitmap(),
                                    EnsureBitmapSize(bitmap_24, 17)));
 }
 
 // If resource set is empty, |GetRepresentation| should synchronously return
 // default icon, without notifying observer of image change.
 TEST_F(ExtensionIconImageTest, NoResources) {
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Manifest::INVALID_LOCATION));
-  ASSERT_TRUE(extension.get() != NULL);
+  ASSERT_TRUE(extension.get() != nullptr);
 
   ExtensionIconSet empty_icon_set;
   gfx::ImageSkia default_icon = GetDefaultIcon();
 
   const int kRequestedSize = 24;
   IconImage image(browser_context(),
                   extension.get(),
                   empty_icon_set,
                   kRequestedSize,
                   default_icon,
@@ skipping 17 matching lines @@
           default_icon.GetRepresentation(1.0f).sk_bitmap(),
           kRequestedSize)));
 }
 
 // If resource set is invalid, image load should be done asynchronously and
 // the observer should be notified when it's done. |GetRepresentation| should
 // return the default icon representation once image load is done.
 TEST_F(ExtensionIconImageTest, InvalidResource) {
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Manifest::INVALID_LOCATION));
-  ASSERT_TRUE(extension.get() != NULL);
+  ASSERT_TRUE(extension.get() != nullptr);
 
   const int kInvalidIconSize = 24;
   ExtensionIconSet invalid_icon_set;
   invalid_icon_set.Add(kInvalidIconSize, "invalid.png");
 
   gfx::ImageSkia default_icon = GetDefaultIcon();
 
   IconImage image(browser_context(),
                   extension.get(),
                   invalid_icon_set,
@@ skipping 17 matching lines @@
       EnsureBitmapSize(
           default_icon.GetRepresentation(1.0f).sk_bitmap(),
           kInvalidIconSize)));
 }
 
 // Test that IconImage works with lazily (but synchronously) created default
 // icon when IconImage returns synchronously.
 TEST_F(ExtensionIconImageTest, LazyDefaultIcon) {
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Manifest::INVALID_LOCATION));
-  ASSERT_TRUE(extension.get() != NULL);
+  ASSERT_TRUE(extension.get() != nullptr);
 
   gfx::ImageSkia default_icon = GetDefaultIcon();
   gfx::ImageSkia lazy_default_icon(new MockImageSkiaSource(default_icon),
                                     default_icon.size());
 
   ExtensionIconSet empty_icon_set;
 
   const int kRequestedSize = 128;
   IconImage image(browser_context(),
                   extension.get(),
@@ skipping 16 matching lines @@
 
   // We should have a default icon representation.
   ASSERT_EQ(1u, image.image_skia().image_reps().size());
 }
 
 // Test that IconImage works with lazily (but synchronously) created default
 // icon when IconImage returns asynchronously.
 TEST_F(ExtensionIconImageTest, LazyDefaultIcon_AsyncIconImage) {
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Manifest::INVALID_LOCATION));
-  ASSERT_TRUE(extension.get() != NULL);
+  ASSERT_TRUE(extension.get() != nullptr);
 
   gfx::ImageSkia default_icon = GetDefaultIcon();
   gfx::ImageSkia lazy_default_icon(new MockImageSkiaSource(default_icon),
                                     default_icon.size());
 
   const int kInvalidIconSize = 24;
   ExtensionIconSet invalid_icon_set;
   invalid_icon_set.Add(kInvalidIconSize, "invalid.png");
 
   IconImage image(browser_context(),
@@ skipping 22 matching lines @@
           kInvalidIconSize)));
 }
 
 // Tests behavior of image created by IconImage after IconImage host goes
 // away. The image should still return loaded representations. If requested
 // representation was not loaded while IconImage host was around, transparent
 // representations should be returned.
 TEST_F(ExtensionIconImageTest, IconImageDestruction) {
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Manifest::INVALID_LOCATION));
-  ASSERT_TRUE(extension.get() != NULL);
+  ASSERT_TRUE(extension.get() != nullptr);
 
   gfx::ImageSkia default_icon = GetDefaultIcon();
 
   // Load images we expect to find as representations in icon_image, so we
   // can later use them to validate icon_image.
   SkBitmap bitmap_16 = GetTestBitmap(extension.get(), "16.png", 16);
   ASSERT_FALSE(bitmap_16.empty());
 
   scoped_ptr<IconImage> image(
       new IconImage(browser_context(),
                     extension.get(),
                     IconsInfo::GetIcons(extension.get()),
                     16,
                     default_icon,
                     this));
 
   // Load an image representation.
   gfx::ImageSkiaRep representation =
       image->image_skia().GetRepresentation(1.0f);
 
   WaitForImageLoad();
   EXPECT_EQ(1, ImageLoadedCount());
   ASSERT_EQ(1u, image->image_skia().image_reps().size());
 
   // Stash loaded image skia, and destroy |image|.
   gfx::ImageSkia image_skia = image->image_skia();
   image.reset();
-  extension = NULL;
+  extension = nullptr;
 
   // Image skia should still be able to get previously loaded representation.
   representation = image_skia.GetRepresentation(1.0f);
 
   EXPECT_EQ(1.0f, representation.scale());
   EXPECT_EQ(16, representation.pixel_width());
   EXPECT_TRUE(gfx::BitmapsAreEqual(representation.sk_bitmap(), bitmap_16));
 
   // When requesting another representation, we should not crash and return some
   // image of the size. It could be blank or a rescale from the existing 1.0f
   // icon.
   representation = image_skia.GetRepresentation(2.0f);
 
   EXPECT_EQ(16, representation.GetWidth());
   EXPECT_EQ(16, representation.GetHeight());
   EXPECT_EQ(2.0f, representation.scale());
 }
 
 }  // namespace extensions