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

chrome/browser/extensions/activity_log/fullstream_ui_policy.cc

 // Copyright 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/fullstream_ui_policy.h"
 
 #include <stddef.h>
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/extensions/activity_log/activity_action_constants.h"
 #include "chrome/browser/extensions/activity_log/activity_database.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "extensions/common/dom_action_types.h"
 #include "extensions/common/extension.h"
 #include "sql/statement.h"
@@ skipping 88 matching lines @@
     }
   }
 
   if (!transaction.Commit())
     return false;
 
   queued_actions_.clear();
   return true;
 }
 
-scoped_ptr<Action::ActionVector> FullStreamUIPolicy::DoReadFilteredData(
+std::unique_ptr<Action::ActionVector> FullStreamUIPolicy::DoReadFilteredData(
     const std::string& extension_id,
     const Action::ActionType type,
     const std::string& api_name,
     const std::string& page_url,
     const std::string& arg_url,
     const int days_ago) {
   // Ensure data is flushed to the database first so that we query over all
   // data.
   activity_database()->AdviseFlush(ActivityDatabase::kFlushImmediately);
-  scoped_ptr<Action::ActionVector> actions(new Action::ActionVector());
+  std::unique_ptr<Action::ActionVector> actions(new Action::ActionVector());
 
   sql::Connection* db = GetDatabaseConnection();
   if (!db) {
     return actions;
   }
 
   // Build up the query based on which parameters were specified.
   std::string where_str = "";
   std::string where_next = "";
   if (!extension_id.empty()) {
@@ skipping 45 matching lines @@
 
   // Execute the query and get results.
   while (query.is_valid() && query.Step()) {
     scoped_refptr<Action> action =
         new Action(query.ColumnString(0),
                    base::Time::FromInternalValue(query.ColumnInt64(1)),
                    static_cast<Action::ActionType>(query.ColumnInt(2)),
                    query.ColumnString(3), query.ColumnInt64(9));
 
     if (query.ColumnType(4) != sql::COLUMN_TYPE_NULL) {
-      scoped_ptr<base::Value> parsed_value =
+      std::unique_ptr<base::Value> parsed_value =
           base::JSONReader::Read(query.ColumnString(4));
       if (parsed_value && parsed_value->IsType(base::Value::TYPE_LIST)) {
-        action->set_args(make_scoped_ptr(
+        action->set_args(base::WrapUnique(
             static_cast<base::ListValue*>(parsed_value.release())));
       }
     }
 
     action->ParsePageUrl(query.ColumnString(5));
     action->set_page_title(query.ColumnString(6));
     action->ParseArgUrl(query.ColumnString(7));
 
     if (query.ColumnType(8) != sql::COLUMN_TYPE_NULL) {
-      scoped_ptr<base::Value> parsed_value =
+      std::unique_ptr<base::Value> parsed_value =
           base::JSONReader::Read(query.ColumnString(8));
       if (parsed_value && parsed_value->IsType(base::Value::TYPE_DICTIONARY)) {
-        action->set_other(make_scoped_ptr(
+        action->set_other(base::WrapUnique(
             static_cast<base::DictionaryValue*>(parsed_value.release())));
       }
     }
     actions->push_back(action);
   }
 
   return actions;
 }
 
 void FullStreamUIPolicy::DoRemoveActions(
@@ skipping 164 matching lines @@
   ScheduleAndForget(activity_database(), &ActivityDatabase::Close);
 }
 
 void FullStreamUIPolicy::ReadFilteredData(
     const std::string& extension_id,
     const Action::ActionType type,
     const std::string& api_name,
     const std::string& page_url,
     const std::string& arg_url,
     const int days_ago,
-    const base::Callback
-        <void(scoped_ptr<Action::ActionVector>)>& callback) {
+    const base::Callback<void(std::unique_ptr<Action::ActionVector>)>&
+        callback) {
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB,
       FROM_HERE,
       base::Bind(&FullStreamUIPolicy::DoReadFilteredData,
                  base::Unretained(this),
                  extension_id,
                  type,
                  api_name,
                  page_url,
                  arg_url,
@@ skipping 33 matching lines @@
 }
 
 void FullStreamUIPolicy::QueueAction(scoped_refptr<Action> action) {
   if (activity_database()->is_db_valid()) {
     queued_actions_.push_back(action);
     activity_database()->AdviseFlush(queued_actions_.size());
   }
 }
 
 }  // namespace extensions