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

chrome/browser/ui/app_list/search/webstore/webstore_provider.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/ui/app_list/search/webstore/webstore_provider.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 77 matching lines @@
                    base::Unretained(this)),
         profile_->GetRequestContext()));
   }
 
   query_pending_ = true;
   StartThrottledQuery(base::Bind(&WebstoreProvider::StartQuery,
                                  base::Unretained(this)));
 
   // Add a placeholder result which when clicked will run the user's query in a
   // browser. This placeholder is removed when the search results arrive.
-  Add(scoped_ptr<SearchResult>(
+  Add(std::unique_ptr<SearchResult>(
       new SearchWebstoreResult(profile_, controller_, query_)));
 }
 
 void WebstoreProvider::Stop() {
   if (webstore_search_)
     webstore_search_->Stop();
 }
 
 void WebstoreProvider::StartQuery() {
   // |query_| can be NULL when the query is scheduled but then canceled.
   if (!webstore_search_ || query_.empty())
     return;
 
   webstore_search_->Start(extension_urls::GetWebstoreJsonSearchUrl(
       query_, g_browser_process->GetApplicationLocale()));
 }
 
 void WebstoreProvider::OnWebstoreSearchFetched(
-    scoped_ptr<base::DictionaryValue> json) {
+    std::unique_ptr<base::DictionaryValue> json) {
   ProcessWebstoreSearchResults(json.get());
   cache_->Put(WebserviceCache::WEBSTORE, query_, std::move(json));
   query_pending_ = false;
 
   if (!webstore_search_fetched_callback_.is_null())
     webstore_search_fetched_callback_.Run();
 }
 
 void WebstoreProvider::ProcessWebstoreSearchResults(
     const base::DictionaryValue* json) {
   const base::ListValue* result_list = NULL;
   if (!json ||
       !json->GetList(kKeyResults, &result_list) ||
       !result_list ||
       result_list->empty()) {
     return;
   }
 
   bool first_result = true;
   TokenizedString query(base::UTF8ToUTF16(query_));
   for (base::ListValue::const_iterator it = result_list->begin();
        it != result_list->end();
        ++it) {
     const base::DictionaryValue* dict;
     if (!(*it)->GetAsDictionary(&dict))
       continue;
 
-    scoped_ptr<SearchResult> result(CreateResult(query, *dict));
+    std::unique_ptr<SearchResult> result(CreateResult(query, *dict));
     if (!result)
       continue;
 
     if (first_result) {
       // Clears "search in webstore" place holder results.
       ClearResults();
       first_result = false;
     }
 
     Add(std::move(result));
   }
 }
 
-scoped_ptr<SearchResult> WebstoreProvider::CreateResult(
+std::unique_ptr<SearchResult> WebstoreProvider::CreateResult(
     const TokenizedString& query,
     const base::DictionaryValue& dict) {
   std::string app_id;
   std::string localized_name;
   std::string icon_url_string;
   bool is_paid = false;
   if (!dict.GetString(kKeyId, &app_id) ||
       !dict.GetString(kKeyLocalizedName, &localized_name) ||
       !dict.GetString(kKeyIconUrl, &icon_url_string) ||
       !dict.GetBoolean(kKeyIsPaid, &is_paid)) {
-    return scoped_ptr<SearchResult>();
+    return std::unique_ptr<SearchResult>();
   }
 
   GURL icon_url(icon_url_string);
   if (!icon_url.is_valid())
-    return scoped_ptr<SearchResult>();
+    return std::unique_ptr<SearchResult>();
 
   std::string item_type_string;
   dict.GetString(kKeyItemType, &item_type_string);
   extensions::Manifest::Type item_type = ParseItemType(item_type_string);
 
   // Calculate the relevance score by matching the query with the title. Results
   // with a match score of 0 are discarded. This will also be used to set the
   // title tags (highlighting which parts of the title matched the search
   // query).
   TokenizedString title(base::UTF8ToUTF16(localized_name));
   TokenizedStringMatch match;
   if (!match.Calculate(query, title))
-    return scoped_ptr<SearchResult>();
+    return std::unique_ptr<SearchResult>();
 
-  scoped_ptr<SearchResult> result(new WebstoreResult(
+  std::unique_ptr<SearchResult> result(new WebstoreResult(
       profile_, app_id, icon_url, is_paid, item_type, controller_));
   result->UpdateFromMatch(title, match);
   return result;
 }
 
 }  // namespace app_list