Convert //extensions/{common,shell} from scoped_ptr to std::unique_ptr

extensions/common/manifest_handlers/options_page_info.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/common/manifest_handlers/options_page_info.h"
 
+#include <memory>
+
 #include "base/files/file_util.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "extensions/common/api/extensions_manifest_types.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/file_util.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/strings/grit/extensions_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using base::ASCIIToUTF16;
@@ skipping 78 matching lines @@
   OptionsPageInfo* info = GetOptionsPageInfo(extension);
   return info && info->chrome_styles_;
 }
 
 // static
 bool OptionsPageInfo::ShouldOpenInTab(const Extension* extension) {
   OptionsPageInfo* info = GetOptionsPageInfo(extension);
   return info && info->open_in_tab_;
 }
 
-scoped_ptr<OptionsPageInfo> OptionsPageInfo::Create(
+std::unique_ptr<OptionsPageInfo> OptionsPageInfo::Create(
     Extension* extension,
     const base::Value* options_ui_value,
     const std::string& options_page_string,
     std::vector<InstallWarning>* install_warnings,
     base::string16* error) {
   GURL options_page;
   // Chrome styling is always opt-in.
   bool chrome_style = false;
   // Extensions can opt in or out to opening in a tab, and users can choose via
   // the --embedded-extension-options flag which should be the default.
   bool open_in_tab = !FeatureSwitch::embedded_extension_options()->IsEnabled();
 
   // Parse the options_ui object.
   if (options_ui_value) {
     base::string16 options_ui_error;
 
-    scoped_ptr<OptionsUI> options_ui =
+    std::unique_ptr<OptionsUI> options_ui =
         OptionsUI::FromValue(*options_ui_value, &options_ui_error);
     if (!options_ui_error.empty()) {
       // OptionsUI::FromValue populates |error| both when there are
       // errors (in which case |options_ui| will be NULL) and warnings
       // (in which case |options_ui| will be valid). Either way, show it
       // as an install warning.
       install_warnings->push_back(
           InstallWarning(base::UTF16ToASCII(options_ui_error)));
     }
 
@@ skipping 16 matching lines @@
   }
 
   // Parse the legacy options_page entry if there was no entry for
   // options_ui.page.
   if (!options_page_string.empty() && !options_page.is_valid()) {
     if (!ParseOptionsUrl(extension,
                          options_page_string,
                          keys::kOptionsPage,
                          error,
                          &options_page)) {
-      return scoped_ptr<OptionsPageInfo>();
+      return std::unique_ptr<OptionsPageInfo>();
     }
   }
 
-  return make_scoped_ptr(
+  return base::WrapUnique(
       new OptionsPageInfo(options_page, chrome_style, open_in_tab));
 }
 
 OptionsPageManifestHandler::OptionsPageManifestHandler() {
 }
 
 OptionsPageManifestHandler::~OptionsPageManifestHandler() {
 }
 
 bool OptionsPageManifestHandler::Parse(Extension* extension,
                                        base::string16* error) {
   std::vector<InstallWarning> install_warnings;
   const Manifest* manifest = extension->manifest();
 
   std::string options_page_string;
   if (manifest->HasPath(keys::kOptionsPage) &&
       !manifest->GetString(keys::kOptionsPage, &options_page_string)) {
     *error = ErrorUtils::FormatErrorMessageUTF16(errors::kInvalidOptionsPage,
                                                  keys::kOptionsPage);
     return false;
   }
 
   const base::Value* options_ui_value = NULL;
   ignore_result(manifest->Get(keys::kOptionsUI, &options_ui_value));
 
-  scoped_ptr<OptionsPageInfo> info =
-      OptionsPageInfo::Create(extension,
-                              options_ui_value,
-                              options_page_string,
-                              &install_warnings,
-                              error);
+  std::unique_ptr<OptionsPageInfo> info =
+      OptionsPageInfo::Create(extension, options_ui_value, options_page_string,
+                              &install_warnings, error);
   if (!info)
     return false;
 
   extension->AddInstallWarnings(install_warnings);
   extension->SetManifestData(keys::kOptionsUI, info.release());
   return true;
 }
 
 bool OptionsPageManifestHandler::Validate(
     const Extension* extension,
@@ skipping 14 matching lines @@
   }
   return true;
 }
 
 const std::vector<std::string> OptionsPageManifestHandler::Keys() const {
   static const char* keys[] = {keys::kOptionsPage, keys::kOptionsUI};
   return std::vector<std::string>(keys, keys + arraysize(keys));
 }
 
 }  // namespace extensions