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

chrome/browser/extensions/permission_messages_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 <stddef.h>
 
+#include <memory>
 #include <utility>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/permissions_updater.h"
 #include "chrome/browser/extensions/test_extension_environment.h"
 #include "chrome/common/extensions/permissions/chrome_permission_message_provider.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/crx_file/id_util.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/common/extension.h"
@@ skipping 26 matching lines @@
 // be changed as the correct behaviour is implemented. TODOs in the test explain
 // the currently problematic behaviour.
 class PermissionMessagesUnittest : public testing::Test {
  public:
   PermissionMessagesUnittest()
       : message_provider_(new ChromePermissionMessageProvider()) {}
   ~PermissionMessagesUnittest() override {}
 
  protected:
   void CreateAndInstallExtensionWithPermissions(
-      scoped_ptr<base::ListValue> required_permissions,
-      scoped_ptr<base::ListValue> optional_permissions) {
+      std::unique_ptr<base::ListValue> required_permissions,
+      std::unique_ptr<base::ListValue> optional_permissions) {
     app_ = test_util::BuildExtension(ExtensionBuilder())
                .MergeManifest(
                    DictionaryBuilder()
                        .Set("permissions", std::move(required_permissions))
                        .Set("optional_permissions",
                             std::move(optional_permissions))
                        .Build())
                .SetID(crx_file::id_util::GenerateId("extension"))
                .SetLocation(Manifest::INTERNAL)
                .Build();
     env_.GetExtensionService()->AddExtension(app_.get());
   }
 
   // Returns the permission messages that would display in the prompt that
   // requests all the optional permissions for the current |app_|.
   std::vector<base::string16> GetOptionalPermissionMessages() {
-    scoped_ptr<const PermissionSet> granted_permissions =
+    std::unique_ptr<const PermissionSet> granted_permissions =
         env_.GetExtensionPrefs()->GetGrantedPermissions(app_->id());
     const PermissionSet& optional_permissions =
         PermissionsParser::GetOptionalPermissions(app_.get());
-    scoped_ptr<const PermissionSet> requested_permissions =
+    std::unique_ptr<const PermissionSet> requested_permissions =
         PermissionSet::CreateDifference(optional_permissions,
                                         *granted_permissions);
     return GetMessages(*requested_permissions);
   }
 
   void GrantOptionalPermissions() {
     PermissionsUpdater perms_updater(env_.profile());
     perms_updater.AddPermissions(
         app_.get(), PermissionsParser::GetOptionalPermissions(app_.get()));
   }
@@ skipping 16 matching lines @@
     for (const PermissionMessage& msg :
          message_provider_->GetPermissionMessages(
              message_provider_->GetAllPermissionIDs(permissions,
                                                     app_->GetType()))) {
       messages.push_back(msg.message());
     }
     return messages;
   }
 
   extensions::TestExtensionEnvironment env_;
-  scoped_ptr<ChromePermissionMessageProvider> message_provider_;
+  std::unique_ptr<ChromePermissionMessageProvider> message_provider_;
   scoped_refptr<const Extension> app_;
 
   DISALLOW_COPY_AND_ASSIGN(PermissionMessagesUnittest);
 };
 
 // If an app has both the 'history' and 'tabs' permission, one should hide the
 // other (the 'history' permission has superset permissions).
 TEST_F(PermissionMessagesUnittest, HistoryHidesTabsMessage) {
   CreateAndInstallExtensionWithPermissions(
       ListBuilder().Append("tabs").Append("history").Build(),
@@ skipping 122 matching lines @@
  public:
   USBDevicePermissionMessagesTest()
       : message_provider_(new ChromePermissionMessageProvider()) {}
   ~USBDevicePermissionMessagesTest() override {}
 
   PermissionMessages GetMessages(const PermissionIDSet& permissions) {
     return message_provider_->GetPermissionMessages(permissions);
   }
 
  private:
-  scoped_ptr<ChromePermissionMessageProvider> message_provider_;
+  std::unique_ptr<ChromePermissionMessageProvider> message_provider_;
 };
 
 TEST_F(USBDevicePermissionMessagesTest, SingleDevice) {
   {
     const char kMessage[] =
         "Access any PVR Mass Storage from HUMAX Co., Ltd. via USB";
 
-    scoped_ptr<base::ListValue> permission_list(new base::ListValue());
+    std::unique_ptr<base::ListValue> permission_list(new base::ListValue());
     permission_list->Append(
         UsbDevicePermissionData(0x02ad, 0x138c, -1).ToValue().release());
 
     UsbDevicePermission permission(
         PermissionsInfo::GetInstance()->GetByID(APIPermission::kUsbDevice));
     ASSERT_TRUE(permission.FromValue(permission_list.get(), NULL, NULL));
 
     PermissionMessages messages = GetMessages(permission.GetPermissions());
     ASSERT_EQ(1U, messages.size());
     EXPECT_EQ(base::ASCIIToUTF16(kMessage), messages.front().message());
   }
   {
     const char kMessage[] = "Access USB devices from HUMAX Co., Ltd.";
 
-    scoped_ptr<base::ListValue> permission_list(new base::ListValue());
+    std::unique_ptr<base::ListValue> permission_list(new base::ListValue());
     permission_list->Append(
         UsbDevicePermissionData(0x02ad, 0x138d, -1).ToValue().release());
 
     UsbDevicePermission permission(
         PermissionsInfo::GetInstance()->GetByID(APIPermission::kUsbDevice));
     ASSERT_TRUE(permission.FromValue(permission_list.get(), NULL, NULL));
 
     PermissionMessages messages = GetMessages(permission.GetPermissions());
     ASSERT_EQ(1U, messages.size());
     EXPECT_EQ(base::ASCIIToUTF16(kMessage), messages.front().message());
   }
   {
     const char kMessage[] = "Access USB devices from an unknown vendor";
 
-    scoped_ptr<base::ListValue> permission_list(new base::ListValue());
+    std::unique_ptr<base::ListValue> permission_list(new base::ListValue());
     permission_list->Append(
         UsbDevicePermissionData(0x02ae, 0x138d, -1).ToValue().release());
 
     UsbDevicePermission permission(
         PermissionsInfo::GetInstance()->GetByID(APIPermission::kUsbDevice));
     ASSERT_TRUE(permission.FromValue(permission_list.get(), NULL, NULL));
 
     PermissionMessages messages = GetMessages(permission.GetPermissions());
     ASSERT_EQ(1U, messages.size());
     EXPECT_EQ(base::ASCIIToUTF16(kMessage), messages.front().message());
   }
 }
 
 TEST_F(USBDevicePermissionMessagesTest, MultipleDevice) {
   const char kMessage[] = "Access any of these USB devices";
   const char* kDetails[] = {
       "PVR Mass Storage from HUMAX Co., Ltd.",
       "unknown devices from HUMAX Co., Ltd.",
       "devices from an unknown vendor"
   };
 
   // Prepare data set
-  scoped_ptr<base::ListValue> permission_list(new base::ListValue());
+  std::unique_ptr<base::ListValue> permission_list(new base::ListValue());
   permission_list->Append(
       UsbDevicePermissionData(0x02ad, 0x138c, -1).ToValue().release());
   // This device's product ID is not in Chrome's database.
   permission_list->Append(
       UsbDevicePermissionData(0x02ad, 0x138d, -1).ToValue().release());
   // This additional unknown product will be collapsed into the entry above.
   permission_list->Append(
       UsbDevicePermissionData(0x02ad, 0x138e, -1).ToValue().release());
   // This device's vendor ID is not in Chrome's database.
   permission_list->Append(
@@ skipping 10 matching lines @@
   ASSERT_EQ(1U, messages.size());
   EXPECT_EQ(base::ASCIIToUTF16(kMessage), messages.front().message());
   const std::vector<base::string16>& submessages =
       messages.front().submessages();
   ASSERT_EQ(arraysize(kDetails), submessages.size());
   for (size_t i = 0; i < submessages.size(); i++)
     EXPECT_EQ(base::ASCIIToUTF16(kDetails[i]), submessages[i]);
 }
 
 }  // namespace extensions