Convert //chrome/browser/ui from scoped_ptr to std::unique_ptr

chrome/browser/ui/content_settings/content_setting_bubble_model_unittest.cc

 // Copyright (c) 2012 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 <stddef.h>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
@@ skipping 25 matching lines @@
  protected:
   void SetUp() override {
     ChromeRenderViewHostTestHarness::SetUp();
     TabSpecificContentSettings::CreateForWebContents(web_contents());
     InfoBarService::CreateForWebContents(web_contents());
   }
 
   void CheckGeolocationBubble(size_t expected_domains,
                               bool expect_clear_link,
                               bool expect_reload_hint) {
-    scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+    std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
         ContentSettingBubbleModel::CreateContentSettingBubbleModel(
             NULL, web_contents(), profile(),
             CONTENT_SETTINGS_TYPE_GEOLOCATION));
     const ContentSettingBubbleModel::BubbleContent& bubble_content =
         content_setting_bubble_model->bubble_content();
     EXPECT_TRUE(bubble_content.title.empty());
     EXPECT_TRUE(bubble_content.radio_group.radio_items.empty());
     EXPECT_TRUE(bubble_content.list_items.empty());
     EXPECT_EQ(expected_domains, bubble_content.domain_lists.size());
     EXPECT_NE(expect_clear_link || expect_reload_hint,
@@ skipping 11 matching lines @@
     PrefService* prefs = profile()->GetPrefs();
     return prefs->GetString(prefs::kDefaultVideoCaptureDevice);
   }
 };
 
 TEST_F(ContentSettingBubbleModelTest, ImageRadios) {
   TabSpecificContentSettings* content_settings =
       TabSpecificContentSettings::FromWebContents(web_contents());
   content_settings->OnContentBlocked(CONTENT_SETTINGS_TYPE_IMAGES);
 
-  scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+  std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
       ContentSettingBubbleModel::CreateContentSettingBubbleModel(
-         NULL, web_contents(), profile(),
-         CONTENT_SETTINGS_TYPE_IMAGES));
+          NULL, web_contents(), profile(), CONTENT_SETTINGS_TYPE_IMAGES));
   const ContentSettingBubbleModel::BubbleContent& bubble_content =
       content_setting_bubble_model->bubble_content();
   EXPECT_FALSE(bubble_content.title.empty());
   EXPECT_EQ(2U, bubble_content.radio_group.radio_items.size());
   EXPECT_EQ(0, bubble_content.radio_group.default_item);
   EXPECT_TRUE(bubble_content.custom_link.empty());
   EXPECT_FALSE(bubble_content.manage_link.empty());
 }
 
 TEST_F(ContentSettingBubbleModelTest, Cookies) {
   TabSpecificContentSettings* content_settings =
       TabSpecificContentSettings::FromWebContents(web_contents());
   content_settings->OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES);
 
-  scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+  std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
       ContentSettingBubbleModel::CreateContentSettingBubbleModel(
           NULL, web_contents(), profile(), CONTENT_SETTINGS_TYPE_COOKIES));
   const ContentSettingBubbleModel::BubbleContent& bubble_content =
       content_setting_bubble_model->bubble_content();
   std::string title = bubble_content.title;
   EXPECT_FALSE(title.empty());
   ASSERT_EQ(2U, bubble_content.radio_group.radio_items.size());
   EXPECT_FALSE(bubble_content.custom_link.empty());
   EXPECT_TRUE(bubble_content.custom_link_enabled);
   EXPECT_FALSE(bubble_content.manage_link.empty());
@@ skipping 33 matching lines @@
   TabSpecificContentSettings::MicrophoneCameraState microphone_camera_state =
       TabSpecificContentSettings::MICROPHONE_ACCESSED |
       TabSpecificContentSettings::CAMERA_ACCESSED;
   content_settings->OnMediaStreamPermissionSet(security_origin,
                                                microphone_camera_state,
                                                GetDefaultAudioDevice(),
                                                GetDefaultVideoDevice(),
                                                std::string(),
                                                std::string());
 
-  scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
-      new ContentSettingMediaStreamBubbleModel(
-         nullptr, web_contents(), profile()));
+  std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+      new ContentSettingMediaStreamBubbleModel(nullptr, web_contents(),
+                                               profile()));
   const ContentSettingBubbleModel::BubbleContent& bubble_content =
       content_setting_bubble_model->bubble_content();
   EXPECT_EQ(bubble_content.title,
             l10n_util::GetStringUTF8(IDS_MICROPHONE_CAMERA_ALLOWED));
   EXPECT_EQ(2U, bubble_content.radio_group.radio_items.size());
   EXPECT_EQ(bubble_content.radio_group.radio_items[0],
             l10n_util::GetStringFUTF8(
                 IDS_ALLOWED_MEDIASTREAM_MIC_AND_CAMERA_NO_ACTION,
                 url_formatter::FormatUrlForSecurityDisplay(security_origin)));
   EXPECT_EQ(bubble_content.radio_group.radio_items[1],
@@ skipping 32 matching lines @@
       TabSpecificContentSettings::MICROPHONE_BLOCKED |
       TabSpecificContentSettings::CAMERA_ACCESSED |
       TabSpecificContentSettings::CAMERA_BLOCKED;
   content_settings->OnMediaStreamPermissionSet(url,
                                                microphone_camera_state,
                                                GetDefaultAudioDevice(),
                                                GetDefaultVideoDevice(),
                                                std::string(),
                                                std::string());
   {
-    scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
-        new ContentSettingMediaStreamBubbleModel(
-           nullptr, web_contents(), profile()));
+    std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+        new ContentSettingMediaStreamBubbleModel(nullptr, web_contents(),
+                                                 profile()));
     const ContentSettingBubbleModel::BubbleContent& bubble_content =
         content_setting_bubble_model->bubble_content();
     // Test if the correct radio item is selected for the blocked mediastream
     // setting.
     EXPECT_EQ(1, bubble_content.radio_group.default_item);
   }
 
   // Test that the media settings where not changed.
   EXPECT_EQ(CONTENT_SETTING_BLOCK,
             host_content_settings_map->GetContentSetting(
                 url,
                 url,
                 CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
                 std::string()));
   EXPECT_EQ(CONTENT_SETTING_BLOCK,
             host_content_settings_map->GetContentSetting(
                 url,
                 url,
                 CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
                 std::string()));
 
   {
-    scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
-        new ContentSettingMediaStreamBubbleModel(
-           nullptr, web_contents(), profile()));
+    std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+        new ContentSettingMediaStreamBubbleModel(nullptr, web_contents(),
+                                                 profile()));
     // Change the radio setting.
     content_setting_bubble_model->OnRadioClicked(0);
   }
   // Test that the media setting were change correctly.
   EXPECT_EQ(CONTENT_SETTING_ALLOW,
             host_content_settings_map->GetContentSetting(
                 url,
                 url,
                 CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
                 std::string()));
@@ skipping 28 matching lines @@
   TabSpecificContentSettings::MicrophoneCameraState microphone_camera_state =
       TabSpecificContentSettings::MICROPHONE_ACCESSED |
       TabSpecificContentSettings::MICROPHONE_BLOCKED;
   content_settings->OnMediaStreamPermissionSet(url,
                                                microphone_camera_state,
                                                GetDefaultAudioDevice(),
                                                std::string(),
                                                std::string(),
                                                std::string());
   {
-    scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
-        new ContentSettingMediaStreamBubbleModel(
-           nullptr, web_contents(), profile()));
+    std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+        new ContentSettingMediaStreamBubbleModel(nullptr, web_contents(),
+                                                 profile()));
     const ContentSettingBubbleModel::BubbleContent& bubble_content =
         content_setting_bubble_model->bubble_content();
     // Test if the correct radio item is selected for the blocked mediastream
     // setting.
     EXPECT_EQ(1, bubble_content.radio_group.default_item);
     // Change the radio setting.
     content_setting_bubble_model->OnRadioClicked(0);
   }
   // Test that the setting was changed.
   EXPECT_EQ(CONTENT_SETTING_ALLOW,
             host_content_settings_map->GetContentSetting(
                 url,
                 url,
                 CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
                 std::string()));
 
   {
-    scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
-        new ContentSettingMediaStreamBubbleModel(
-           nullptr, web_contents(), profile()));
+    std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+        new ContentSettingMediaStreamBubbleModel(nullptr, web_contents(),
+                                                 profile()));
     const ContentSettingBubbleModel::BubbleContent& bubble_content =
         content_setting_bubble_model->bubble_content();
     // Test that the reload hint is displayed.
     EXPECT_FALSE(bubble_content.custom_link_enabled);
     EXPECT_EQ(bubble_content.custom_link, l10n_util::GetStringUTF8(
               IDS_MEDIASTREAM_SETTING_CHANGED_MESSAGE));
 
     EXPECT_EQ(0, bubble_content.radio_group.default_item);
     // Restore the radio setting (to block).
     content_setting_bubble_model->OnRadioClicked(1);
   }
   // Test that the media settings were changed again.
   EXPECT_EQ(CONTENT_SETTING_BLOCK,
             host_content_settings_map->GetContentSetting(
                 url,
                 url,
                 CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
                 std::string()));
 
   {
-    scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
-        new ContentSettingMediaStreamBubbleModel(
-            nullptr, web_contents(), profile()));
+    std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+        new ContentSettingMediaStreamBubbleModel(nullptr, web_contents(),
+                                                 profile()));
     const ContentSettingBubbleModel::BubbleContent& bubble_content =
         content_setting_bubble_model->bubble_content();
     // Test that the reload hint is not displayed any more.
     EXPECT_FALSE(bubble_content.custom_link_enabled);
     EXPECT_TRUE(bubble_content.custom_link.empty());
 
     EXPECT_EQ(1, bubble_content.radio_group.default_item);
   }
 }
 
@@ skipping 25 matching lines @@
   TabSpecificContentSettings::MicrophoneCameraState microphone_camera_state =
       TabSpecificContentSettings::MICROPHONE_ACCESSED |
       TabSpecificContentSettings::MICROPHONE_BLOCKED;
   content_settings->OnMediaStreamPermissionSet(url,
                                                microphone_camera_state,
                                                GetDefaultAudioDevice(),
                                                std::string(),
                                                std::string(),
                                                std::string());
   {
-    scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
-        new ContentSettingMediaStreamBubbleModel(
-           nullptr, web_contents(), profile()));
+    std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+        new ContentSettingMediaStreamBubbleModel(nullptr, web_contents(),
+                                                 profile()));
     const ContentSettingBubbleModel::BubbleContent& bubble_content =
         content_setting_bubble_model->bubble_content();
     EXPECT_TRUE(bubble_content.custom_link.empty());
 
     EXPECT_EQ(1U, bubble_content.media_menus.size());
     EXPECT_EQ(content::MEDIA_DEVICE_AUDIO_CAPTURE,
               bubble_content.media_menus.begin()->first);
     EXPECT_FALSE(bubble_content.media_menus.begin()->second.disabled);
     // The first audio device should be selected by default.
     EXPECT_TRUE(fake_audio_device1.IsEqual(
                 bubble_content.media_menus.begin()->second.selected_device));
 
     // Select a different (the second) device.
     content_setting_bubble_model->OnMediaMenuClicked(
         content::MEDIA_DEVICE_AUDIO_CAPTURE,
         fake_audio_device2.id);
   }
   {
-    scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
-        new ContentSettingMediaStreamBubbleModel(
-           nullptr, web_contents(), profile()));
+    std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+        new ContentSettingMediaStreamBubbleModel(nullptr, web_contents(),
+                                                 profile()));
     const ContentSettingBubbleModel::BubbleContent& bubble_content =
         content_setting_bubble_model->bubble_content();
     EXPECT_EQ(1U, bubble_content.media_menus.size());
     EXPECT_EQ(content::MEDIA_DEVICE_AUDIO_CAPTURE,
               bubble_content.media_menus.begin()->first);
     EXPECT_FALSE(bubble_content.media_menus.begin()->second.disabled);
     // The second audio device should be selected.
     EXPECT_TRUE(fake_audio_device2.IsEqual(
                 bubble_content.media_menus.begin()->second.selected_device));
     // The "settings changed" message should not be displayed when there is no
     // active capture.
     EXPECT_FALSE(bubble_content.custom_link_enabled);
     EXPECT_TRUE(bubble_content.custom_link.empty());
   }
 
   // Simulate that an audio stream is being captured.
   scoped_refptr<MediaStreamCaptureIndicator> indicator =
       MediaCaptureDevicesDispatcher::GetInstance()->
         GetMediaStreamCaptureIndicator();
-  scoped_ptr<content::MediaStreamUI> media_stream_ui =
+  std::unique_ptr<content::MediaStreamUI> media_stream_ui =
       indicator->RegisterMediaStream(web_contents(), audio_devices);
   media_stream_ui->OnStarted(base::Closure());
   microphone_camera_state &= ~TabSpecificContentSettings::MICROPHONE_BLOCKED;
   content_settings->OnMediaStreamPermissionSet(url,
                                                microphone_camera_state,
                                                GetDefaultAudioDevice(),
                                                std::string(),
                                                std::string(),
                                                std::string());
 
   {
-    scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
-        new ContentSettingMediaStreamBubbleModel(
-           nullptr, web_contents(), profile()));
+    std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+        new ContentSettingMediaStreamBubbleModel(nullptr, web_contents(),
+                                                 profile()));
     const ContentSettingBubbleModel::BubbleContent& bubble_content =
         content_setting_bubble_model->bubble_content();
     // Settings not changed yet, so the "settings changed" message should not be
     // shown.
     EXPECT_TRUE(bubble_content.custom_link.empty());
 
     EXPECT_EQ(1U, bubble_content.media_menus.size());
     EXPECT_EQ(content::MEDIA_DEVICE_AUDIO_CAPTURE,
               bubble_content.media_menus.begin()->first);
     EXPECT_FALSE(bubble_content.media_menus.begin()->second.disabled);
     EXPECT_TRUE(fake_audio_device2.IsEqual(
                 bubble_content.media_menus.begin()->second.selected_device));
 
     // Select a different different device.
     content_setting_bubble_model->OnMediaMenuClicked(
         content::MEDIA_DEVICE_AUDIO_CAPTURE,
         fake_audio_device3.id);
   }
 
   {
-    scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
-        new ContentSettingMediaStreamBubbleModel(
-            nullptr, web_contents(), profile()));
+    std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+        new ContentSettingMediaStreamBubbleModel(nullptr, web_contents(),
+                                                 profile()));
     const ContentSettingBubbleModel::BubbleContent& bubble_content =
         content_setting_bubble_model->bubble_content();
     // Test that the reload hint is displayed.
     EXPECT_FALSE(bubble_content.custom_link_enabled);
     EXPECT_EQ(bubble_content.custom_link, l10n_util::GetStringUTF8(
               IDS_MEDIASTREAM_SETTING_CHANGED_MESSAGE));
   }
 
   // Simulate that yet another audio stream capture request was initiated.
   microphone_camera_state |= TabSpecificContentSettings::MICROPHONE_BLOCKED;
   content_settings->OnMediaStreamPermissionSet(url,
                                                microphone_camera_state,
                                                GetDefaultAudioDevice(),
                                                std::string(),
                                                std::string(),
                                                std::string());
 
   {
-    scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
-        new ContentSettingMediaStreamBubbleModel(
-           nullptr, web_contents(), profile()));
+    std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+        new ContentSettingMediaStreamBubbleModel(nullptr, web_contents(),
+                                                 profile()));
     const ContentSettingBubbleModel::BubbleContent& bubble_content =
         content_setting_bubble_model->bubble_content();
     // Test that the reload hint is not displayed any more, because this is a
     // new permission request.
     EXPECT_FALSE(bubble_content.custom_link_enabled);
     EXPECT_TRUE(bubble_content.custom_link.empty());
 
     // Though the audio menu setting should have persisted.
     EXPECT_EQ(1U, bubble_content.media_menus.size());
     EXPECT_EQ(content::MEDIA_DEVICE_AUDIO_CAPTURE,
@@ skipping 15 matching lines @@
   GURL security_origin("http://" + request_host);
   TabSpecificContentSettings::MicrophoneCameraState microphone_camera_state =
       TabSpecificContentSettings::MICROPHONE_ACCESSED;
   content_settings->OnMediaStreamPermissionSet(security_origin,
                                                microphone_camera_state,
                                                GetDefaultAudioDevice(),
                                                std::string(),
                                                std::string(),
                                                std::string());
 
-  scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
-      new ContentSettingMediaStreamBubbleModel(
-          nullptr, web_contents(), profile()));
+  std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+      new ContentSettingMediaStreamBubbleModel(nullptr, web_contents(),
+                                               profile()));
   const ContentSettingBubbleModel::BubbleContent& bubble_content =
       content_setting_bubble_model->bubble_content();
   EXPECT_EQ(bubble_content.title,
             l10n_util::GetStringUTF8(IDS_MICROPHONE_ACCESSED));
   EXPECT_EQ(2U, bubble_content.radio_group.radio_items.size());
   EXPECT_EQ(bubble_content.radio_group.radio_items[0],
             l10n_util::GetStringFUTF8(
                 IDS_ALLOWED_MEDIASTREAM_MIC_NO_ACTION,
                 url_formatter::FormatUrlForSecurityDisplay(security_origin)));
   EXPECT_EQ(bubble_content.radio_group.radio_items[1],
@@ skipping 50 matching lines @@
   GURL security_origin("http://" + request_host);
   TabSpecificContentSettings::MicrophoneCameraState microphone_camera_state =
       TabSpecificContentSettings::CAMERA_ACCESSED;
   content_settings->OnMediaStreamPermissionSet(security_origin,
                                                microphone_camera_state,
                                                std::string(),
                                                GetDefaultVideoDevice(),
                                                std::string(),
                                                std::string());
 
-  scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
-      new ContentSettingMediaStreamBubbleModel(
-          nullptr, web_contents(), profile()));
+  std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+      new ContentSettingMediaStreamBubbleModel(nullptr, web_contents(),
+                                               profile()));
   const ContentSettingBubbleModel::BubbleContent& bubble_content =
       content_setting_bubble_model->bubble_content();
   EXPECT_EQ(bubble_content.title,
             l10n_util::GetStringUTF8(IDS_CAMERA_ACCESSED));
   EXPECT_EQ(2U, bubble_content.radio_group.radio_items.size());
   EXPECT_EQ(bubble_content.radio_group.radio_items[0],
             l10n_util::GetStringFUTF8(
                 IDS_ALLOWED_MEDIASTREAM_CAMERA_NO_ACTION,
                 url_formatter::FormatUrlForSecurityDisplay(security_origin)));
   EXPECT_EQ(bubble_content.radio_group.radio_items[1],
@@ skipping 52 matching lines @@
   // Firstly, add microphone access.
   TabSpecificContentSettings::MicrophoneCameraState microphone_camera_state =
       TabSpecificContentSettings::MICROPHONE_ACCESSED;
   content_settings->OnMediaStreamPermissionSet(security_origin,
                                                microphone_camera_state,
                                                GetDefaultAudioDevice(),
                                                std::string(),
                                                std::string(),
                                                std::string());
 
-  scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
-      new ContentSettingMediaStreamBubbleModel(
-          nullptr, web_contents(), profile()));
+  std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+      new ContentSettingMediaStreamBubbleModel(nullptr, web_contents(),
+                                               profile()));
   const ContentSettingBubbleModel::BubbleContent& bubble_content =
       content_setting_bubble_model->bubble_content();
   EXPECT_EQ(bubble_content.title,
             l10n_util::GetStringUTF8(IDS_MICROPHONE_ACCESSED));
   EXPECT_EQ(2U, bubble_content.radio_group.radio_items.size());
   EXPECT_EQ(bubble_content.radio_group.radio_items[0],
             l10n_util::GetStringFUTF8(
                 IDS_ALLOWED_MEDIASTREAM_MIC_NO_ACTION,
                 url_formatter::FormatUrlForSecurityDisplay(security_origin)));
   EXPECT_EQ(bubble_content.radio_group.radio_items[1],
@@ skipping 33 matching lines @@
 }
 
 TEST_F(ContentSettingBubbleModelTest, Plugins) {
   TabSpecificContentSettings* content_settings =
       TabSpecificContentSettings::FromWebContents(web_contents());
   const base::string16 plugin_name = base::ASCIIToUTF16("plugin_name");
 
   content_settings->OnContentBlockedWithDetail(CONTENT_SETTINGS_TYPE_PLUGINS,
                                                plugin_name);
 
-  scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+  std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
       ContentSettingBubbleModel::CreateContentSettingBubbleModel(
-         NULL, web_contents(), profile(),
-         CONTENT_SETTINGS_TYPE_PLUGINS));
+          NULL, web_contents(), profile(), CONTENT_SETTINGS_TYPE_PLUGINS));
   const ContentSettingBubbleModel::BubbleContent& bubble_content =
       content_setting_bubble_model->bubble_content();
   EXPECT_FALSE(bubble_content.title.empty());
   ASSERT_EQ(1U, bubble_content.list_items.size());
   EXPECT_EQ(plugin_name,
             base::ASCIIToUTF16(bubble_content.list_items[0].title));
   EXPECT_EQ(2U, bubble_content.radio_group.radio_items.size());
   EXPECT_FALSE(bubble_content.custom_link.empty());
   EXPECT_TRUE(bubble_content.custom_link_enabled);
   EXPECT_FALSE(bubble_content.manage_link.empty());
   EXPECT_FALSE(bubble_content.learn_more_link.empty());
 }
 
 TEST_F(ContentSettingBubbleModelTest, PepperBroker) {
   TabSpecificContentSettings* content_settings =
       TabSpecificContentSettings::FromWebContents(web_contents());
   content_settings->OnContentBlocked(CONTENT_SETTINGS_TYPE_PPAPI_BROKER);
 
-  scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+  std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
       ContentSettingBubbleModel::CreateContentSettingBubbleModel(
-         NULL, web_contents(), profile(),
-         CONTENT_SETTINGS_TYPE_PPAPI_BROKER));
+          NULL, web_contents(), profile(), CONTENT_SETTINGS_TYPE_PPAPI_BROKER));
   const ContentSettingBubbleModel::BubbleContent& bubble_content =
       content_setting_bubble_model->bubble_content();
 
   std::string title = bubble_content.title;
   EXPECT_FALSE(title.empty());
   ASSERT_EQ(2U, bubble_content.radio_group.radio_items.size());
   std::string radio1 = bubble_content.radio_group.radio_items[0];
   std::string radio2 = bubble_content.radio_group.radio_items[1];
   EXPECT_FALSE(bubble_content.custom_link_enabled);
   EXPECT_FALSE(bubble_content.manage_link.empty());
@@ skipping 50 matching lines @@
   setting_map->SetDefaultContentSetting(CONTENT_SETTINGS_TYPE_GEOLOCATION,
                                          CONTENT_SETTING_BLOCK);
   CheckGeolocationBubble(2, true, false);
 }
 
 TEST_F(ContentSettingBubbleModelTest, FileURL) {
   std::string file_url("file:///tmp/test.html");
   NavigateAndCommit(GURL(file_url));
   TabSpecificContentSettings::FromWebContents(web_contents())->OnContentBlocked(
       CONTENT_SETTINGS_TYPE_IMAGES);
-  scoped_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
+  std::unique_ptr<ContentSettingBubbleModel> content_setting_bubble_model(
       ContentSettingBubbleModel::CreateContentSettingBubbleModel(
           nullptr, web_contents(), profile(), CONTENT_SETTINGS_TYPE_IMAGES));
   std::string title =
       content_setting_bubble_model->bubble_content().radio_group.radio_items[0];
   ASSERT_NE(std::string::npos, title.find(file_url));
 }
 
 TEST_F(ContentSettingBubbleModelTest, RegisterProtocolHandler) {
   const GURL page_url("http://toplevel.example/");
   NavigateAndCommit(page_url);
@@ skipping 95 matching lines @@
   {
     ProtocolHandler handler = registry.GetHandlerFor("mailto");
     ASSERT_FALSE(handler.IsEmpty());
     EXPECT_EQ(CONTENT_SETTING_ALLOW,
               content_settings->pending_protocol_handler_setting());
     EXPECT_FALSE(registry.IsIgnored(test_handler));
   }
 
   registry.Shutdown();
 }