Convert //extensions/renderer from scoped_ptr to std::unique_ptr

extensions/renderer/i18n_custom_bindings.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/renderer/i18n_custom_bindings.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "content/public/child/v8_value_converter.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_thread.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/message_bundle.h"
 #include "extensions/renderer/script_context.h"
 #include "extensions/renderer/v8_helpers.h"
 #include "third_party/cld_2/src/public/compact_lang_det.h"
 #include "third_party/cld_2/src/public/encodings.h"
 
 namespace extensions {
 
 using namespace v8_helpers;
 
 namespace {
 
 // Max number of languages detected by CLD2.
 const int kCldNumLangs = 3;
 
 struct DetectedLanguage {
   DetectedLanguage(const std::string& language, int percentage)
       : language(language), percentage(percentage) {}
   ~DetectedLanguage() {}
 
   // Returns a new v8::Local<v8::Value> representing the serialized form of
   // this DetectedLanguage object.
-  scoped_ptr<base::DictionaryValue> ToDictionary() const;
+  std::unique_ptr<base::DictionaryValue> ToDictionary() const;
 
   std::string language;
   int percentage;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DetectedLanguage);
 };
 
 // LanguageDetectionResult object that holds detected langugae reliability and
 // array of DetectedLanguage
 struct LanguageDetectionResult {
   explicit LanguageDetectionResult(bool is_reliable)
       : is_reliable(is_reliable) {}
   ~LanguageDetectionResult() {}
 
   // Returns a new v8::Local<v8::Value> representing the serialized form of
   // this Result object.
   v8::Local<v8::Value> ToValue(ScriptContext* context);
 
   // CLD detected language reliability
   bool is_reliable;
 
   // Array of detectedLanguage of size 1-3. The null is returned if
   // there were no languages detected
-  std::vector<scoped_ptr<DetectedLanguage>> languages;
+  std::vector<std::unique_ptr<DetectedLanguage>> languages;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(LanguageDetectionResult);
 };
 
-scoped_ptr<base::DictionaryValue> DetectedLanguage::ToDictionary() const {
-  scoped_ptr<base::DictionaryValue> dict_value(new base::DictionaryValue());
+std::unique_ptr<base::DictionaryValue> DetectedLanguage::ToDictionary() const {
+  std::unique_ptr<base::DictionaryValue> dict_value(
+      new base::DictionaryValue());
   dict_value->SetString("language", language.c_str());
   dict_value->SetInteger("percentage", percentage);
   return dict_value;
 }
 
 v8::Local<v8::Value> LanguageDetectionResult::ToValue(ScriptContext* context) {
   base::DictionaryValue dict_value;
   dict_value.SetBoolean("isReliable", is_reliable);
-  scoped_ptr<base::ListValue> languages_list(new base::ListValue());
+  std::unique_ptr<base::ListValue> languages_list(new base::ListValue());
   for (const auto& language : languages)
     languages_list->Append(language->ToDictionary());
   dict_value.Set("languages", std::move(languages_list));
 
   v8::Local<v8::Context> v8_context = context->v8_context();
   v8::Isolate* isolate = v8_context->GetIsolate();
   v8::EscapableHandleScope handle_scope(isolate);
 
-  scoped_ptr<content::V8ValueConverter> converter(
+  std::unique_ptr<content::V8ValueConverter> converter(
       content::V8ValueConverter::create());
   v8::Local<v8::Value> result = converter->ToV8Value(&dict_value, v8_context);
   return handle_scope.Escape(result);
 }
 
 void InitDetectedLanguages(
     CLD2::Language* languages,
     int* percents,
-    std::vector<scoped_ptr<DetectedLanguage>>* detected_languages) {
+    std::vector<std::unique_ptr<DetectedLanguage>>* detected_languages) {
   for (int i = 0; i < kCldNumLangs; i++) {
     std::string language_code;
     // Convert LanguageCode 'zh' to 'zh-CN' and 'zh-Hant' to 'zh-TW' for
     // Translate server usage. see DetermineTextLanguage in
     // components/translate/core/language_detection/language_detection_util.cc
     if (languages[i] == CLD2::UNKNOWN_LANGUAGE) {
       // Break from the loop since there is no need to save
       // unknown languages
       break;
     } else {
       language_code =
           CLD2::LanguageCode(static_cast<CLD2::Language>(languages[i]));
     }
     detected_languages->push_back(
-        make_scoped_ptr(new DetectedLanguage(language_code, percents[i])));
+        base::WrapUnique(new DetectedLanguage(language_code, percents[i])));
   }
 }
 
 }  // namespace
 
 I18NCustomBindings::I18NCustomBindings(ScriptContext* context)
     : ObjectBackedNativeHandler(context) {
   RouteFunction(
       "GetL10nMessage", "i18n",
       base::Bind(&I18NCustomBindings::GetL10nMessage, base::Unretained(this)));
@@ skipping 111 matching lines @@
   }
 
   LanguageDetectionResult result(is_reliable);
   // populate LanguageDetectionResult with languages and percents
   InitDetectedLanguages(languages, percents, &result.languages);
 
   args.GetReturnValue().Set(result.ToValue(context()));
 }
 
 }  // namespace extensions