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

chrome/browser/extensions/activity_log/activity_actions.cc

 // Copyright (c) 2013 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 "chrome/browser/extensions/activity_log/activity_actions.h"
 
 #include <string>
 
 #include "base/format_macros.h"
 #include "base/json/json_string_value_serializer.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/activity_log/activity_action_constants.h"
 #include "chrome/browser/extensions/activity_log/fullstream_ui_policy.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/dom_action_types.h"
 #include "url/gurl.h"
 
@@ skipping 36 matching lines @@
 Action::~Action() {}
 
 // TODO(mvrable): As an optimization, we might return this directly if the
 // refcount is one.  However, there are likely to be other stray references in
 // many cases that will prevent this optimization.
 scoped_refptr<Action> Action::Clone() const {
   scoped_refptr<Action> clone(
       new Action(
           extension_id(), time(), action_type(), api_name(), action_id()));
   if (args())
-    clone->set_args(make_scoped_ptr(args()->DeepCopy()));
+    clone->set_args(base::WrapUnique(args()->DeepCopy()));
   clone->set_page_url(page_url());
   clone->set_page_title(page_title());
   clone->set_page_incognito(page_incognito());
   clone->set_arg_url(arg_url());
   clone->set_arg_incognito(arg_incognito());
   if (other())
-    clone->set_other(make_scoped_ptr(other()->DeepCopy()));
+    clone->set_other(base::WrapUnique(other()->DeepCopy()));
   return clone;
 }
 
-void Action::set_args(scoped_ptr<base::ListValue> args) {
+void Action::set_args(std::unique_ptr<base::ListValue> args) {
   args_.reset(args.release());
 }
 
 base::ListValue* Action::mutable_args() {
   if (!args_.get()) {
     args_.reset(new base::ListValue());
   }
   return args_.get();
 }
 
 void Action::set_page_url(const GURL& page_url) {
   page_url_ = page_url;
 }
 
 void Action::set_arg_url(const GURL& arg_url) {
   arg_url_ = arg_url;
 }
 
-void Action::set_other(scoped_ptr<base::DictionaryValue> other) {
+void Action::set_other(std::unique_ptr<base::DictionaryValue> other) {
   other_.reset(other.release());
 }
 
 base::DictionaryValue* Action::mutable_other() {
   if (!other_.get()) {
     other_.reset(new base::DictionaryValue());
   }
   return other_.get();
 }
 
@@ skipping 68 matching lines @@
         new std::string(base::StringPrintf("%" PRId64, action_id())));
   if (page_url().is_valid()) {
     if (!page_title().empty())
       result.page_title.reset(new std::string(page_title()));
     result.page_url.reset(new std::string(SerializePageUrl()));
   }
   if (arg_url().is_valid())
     result.arg_url.reset(new std::string(SerializeArgUrl()));
 
   if (other()) {
-    scoped_ptr<ExtensionActivity::Other> other_field(
+    std::unique_ptr<ExtensionActivity::Other> other_field(
         new ExtensionActivity::Other);
     bool prerender;
     if (other()->GetBooleanWithoutPathExpansion(constants::kActionPrerender,
                                                 &prerender)) {
       other_field->prerender.reset(new bool(prerender));
     }
     const base::DictionaryValue* web_request;
     if (other()->GetDictionaryWithoutPathExpansion(constants::kActionWebRequest,
                                                    &web_request)) {
       other_field->web_request.reset(new std::string(
@@ skipping 162 matching lines @@
     std::string rhs_other = ActivityLogPolicy::Util::Serialize(rhs->other());
     if (lhs_other != rhs_other)
       return lhs_other < rhs_other;
   }
 
   // All fields compare as equal if this point is reached.
   return false;
 }
 
 }  // namespace extensions