Replace scoped_ptr with std::unique_ptr in //ui

ui/app_list/search/mixer_unittest.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 "ui/app_list/search/mixer.h"
+
 #include <stddef.h>
 
 #include <set>
 #include <string>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/mock_entropy_provider.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/app_list/app_list_model.h"
 #include "ui/app_list/search/history_types.h"
-#include "ui/app_list/search/mixer.h"
 #include "ui/app_list/search_provider.h"
 #include "ui/app_list/search_result.h"
 
 namespace app_list {
 namespace test {
 
 // Maximum number of results to show in each mixer group.
 const size_t kMaxAppsGroupResults = 4;
 // Ignored unless AppListMixer field trial is "Blended".
 const size_t kMaxOmniboxResults = 4;
 const size_t kMaxWebstoreResults = 2;
 const size_t kMaxPeopleResults = 2;
 
 class TestSearchResult : public SearchResult {
  public:
   TestSearchResult(const std::string& id, double relevance)
       : instance_id_(instantiation_count++) {
     set_id(id);
     set_title(base::UTF8ToUTF16(id));
     set_relevance(relevance);
   }
   ~TestSearchResult() override {}
 
   using SearchResult::set_voice_result;
 
   // SearchResult overrides:
   void Open(int event_flags) override {}
   void InvokeAction(int action_index, int event_flags) override {}
-  scoped_ptr<SearchResult> Duplicate() const override {
-    return make_scoped_ptr(new TestSearchResult(id(), relevance()));
+  std::unique_ptr<SearchResult> Duplicate() const override {
+    return base::WrapUnique(new TestSearchResult(id(), relevance()));
   }
 
   // For reference equality testing. (Addresses cannot be used to test reference
   // equality because it is possible that an object will be allocated at the
   // same address as a previously deleted one.)
   static int GetInstanceId(SearchResult* result) {
     return static_cast<const TestSearchResult*>(result)->instance_id_;
   }
 
  private:
@@ skipping 22 matching lines @@
           base::StringPrintf("%s%d", prefix_.c_str(), static_cast<int>(i));
       double relevance = 1.0 - i / 10.0;
       // If bad_relevance_range_, change the relevances to give results outside
       // of the canonical [0.0, 1.0] range.
       if (bad_relevance_range_)
         relevance = 10.0 - i * 10;
       TestSearchResult* result = new TestSearchResult(id, relevance);
       result->set_display_type(display_type_);
       if (voice_result_indices.find(i) != voice_result_indices.end())
         result->set_voice_result(true);
-      Add(scoped_ptr<SearchResult>(result));
+      Add(std::unique_ptr<SearchResult>(result));
     }
   }
   void Stop() override {}
 
   void set_prefix(const std::string& prefix) { prefix_ = prefix; }
   void set_display_type(SearchResult::DisplayType display_type) {
     display_type_ = display_type;
   }
   void set_count(size_t count) { count_ = count; }
   void set_as_voice_result(size_t index) { voice_result_indices.insert(index); }
@@ skipping 80 matching lines @@
   // Sets whether test runs should be treated as a voice query.
   void set_is_voice_query(bool is_voice_query) {
     is_voice_query_ = is_voice_query;
   }
 
   void AddKnownResult(const std::string& id, KnownResultType type) {
     known_results_[id] = type;
   }
 
  private:
-  scoped_ptr<Mixer> mixer_;
-  scoped_ptr<AppListModel::SearchResults> results_;
+  std::unique_ptr<Mixer> mixer_;
+  std::unique_ptr<AppListModel::SearchResults> results_;
   KnownResults known_results_;
 
   bool is_voice_query_;
 
   ScopedVector<TestSearchProvider> providers_;
 
   base::FieldTrialList field_trial_list_;
 
   DISALLOW_COPY_AND_ASSIGN(MixerTest);
 };
@@ skipping 233 matching lines @@
 
   RunQuery();
 
   // If the results are correctly clamped to the range [0.0, 1.0], the boost to
   // "people1" will push it over the first result. If not, the massive base
   // score of "people0" will erroneously keep it on top.
   EXPECT_EQ("people1,people0", GetResults());
 }
 
 TEST_P(MixerTest, Publish) {
-  scoped_ptr<SearchResult> result1(new TestSearchResult("app1", 0));
-  scoped_ptr<SearchResult> result2(new TestSearchResult("app2", 0));
-  scoped_ptr<SearchResult> result3(new TestSearchResult("app3", 0));
-  scoped_ptr<SearchResult> result3_copy = result3->Duplicate();
-  scoped_ptr<SearchResult> result4(new TestSearchResult("app4", 0));
-  scoped_ptr<SearchResult> result5(new TestSearchResult("app5", 0));
+  std::unique_ptr<SearchResult> result1(new TestSearchResult("app1", 0));
+  std::unique_ptr<SearchResult> result2(new TestSearchResult("app2", 0));
+  std::unique_ptr<SearchResult> result3(new TestSearchResult("app3", 0));
+  std::unique_ptr<SearchResult> result3_copy = result3->Duplicate();
+  std::unique_ptr<SearchResult> result4(new TestSearchResult("app4", 0));
+  std::unique_ptr<SearchResult> result5(new TestSearchResult("app5", 0));
 
   AppListModel::SearchResults ui_results;
 
   // Publish the first three results to |ui_results|.
   Mixer::SortedResults new_results;
   new_results.push_back(Mixer::SortData(result1.get(), 1.0f));
   new_results.push_back(Mixer::SortData(result2.get(), 1.0f));
   new_results.push_back(Mixer::SortData(result3.get(), 1.0f));
 
   Mixer::Publish(new_results, &ui_results);
@@ skipping 65 matching lines @@
   EXPECT_EQ(old_ui_result_ids[1],
             TestSearchResult::GetInstanceId(ui_results.GetItemAt(0)));
   EXPECT_EQ(old_ui_result_ids[2],
             TestSearchResult::GetInstanceId(ui_results.GetItemAt(2)));
 }
 
 INSTANTIATE_TEST_CASE_P(MixerTestInstance, MixerTest, testing::Bool());
 
 }  // namespace test
 }  // namespace app_list