Convert Pass()→std::move() in //chrome/browser/ui

chrome/browser/ui/webui/omnibox/omnibox_ui_handler.cc

 // Copyright (c) 2012 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/webui/omnibox/omnibox_ui_handler.h"
 
 #include <stddef.h>
-
 #include <string>
+#include <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/autocomplete/chrome_autocomplete_provider_client.h"
 #include "chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.h"
@@ skipping 22 matching lines @@
                      AutocompleteMatch::AdditionalInfo> {
   static mojo::Array<AutocompleteAdditionalInfoPtr> Convert(
       const AutocompleteMatch::AdditionalInfo& input) {
     mojo::Array<AutocompleteAdditionalInfoPtr> array(input.size());
     size_t index = 0;
     for (AutocompleteMatch::AdditionalInfo::const_iterator i = input.begin();
          i != input.end(); ++i, index++) {
       AutocompleteAdditionalInfoPtr item(AutocompleteAdditionalInfo::New());
       item->key = i->first;
       item->value = i->second;
-      array[index] = item.Pass();
+      array[index] = std::move(item);
     }
-    return array.Pass();
+    return array;
   }
 };
 
 template <>
 struct TypeConverter<AutocompleteMatchMojoPtr, AutocompleteMatch> {
   static AutocompleteMatchMojoPtr Convert(const AutocompleteMatch& input) {
     AutocompleteMatchMojoPtr result(AutocompleteMatchMojo::New());
     if (input.provider != NULL) {
       result->provider_name = input.provider->GetName();
       result->provider_done = input.provider->done();
@@ skipping 18 matching lines @@
     if (input.associated_keyword.get() != NULL) {
       result->associated_keyword =
           mojo::String::From(input.associated_keyword->keyword);
     }
     result->keyword = mojo::String::From(input.keyword);
     result->duplicates = static_cast<int32_t>(input.duplicate_matches.size());
     result->from_previous = input.from_previous;
 
     result->additional_info =
         mojo::Array<AutocompleteAdditionalInfoPtr>::From(input.additional_info);
-    return result.Pass();
+    return result;
   }
 };
 
 template <>
 struct TypeConverter<AutocompleteResultsForProviderMojoPtr,
                      scoped_refptr<AutocompleteProvider> > {
   static AutocompleteResultsForProviderMojoPtr Convert(
       const scoped_refptr<AutocompleteProvider>& input) {
     AutocompleteResultsForProviderMojoPtr result(
         AutocompleteResultsForProviderMojo::New());
     result->provider_name = input->GetName();
     result->results =
         mojo::Array<AutocompleteMatchMojoPtr>::From(input->matches());
-    return result.Pass();
+    return result;
   }
 };
 
 }  // namespace mojo
 
 OmniboxUIHandler::OmniboxUIHandler(
     Profile* profile,
     mojo::InterfaceRequest<OmniboxUIHandlerMojo> request)
-    : profile_(profile),
-      binding_(this, request.Pass()) {
+    : profile_(profile), binding_(this, std::move(request)) {
   ResetController();
 }
 
 OmniboxUIHandler::~OmniboxUIHandler() {
 }
 
 void OmniboxUIHandler::OnResultChanged(bool default_match_changed) {
   OmniboxResultMojoPtr result(OmniboxResultMojo::New());
   result->done = controller_->done();
   result->time_since_omnibox_started_ms =
@@ skipping 29 matching lines @@
     for (size_t i = 0; i < result->results_by_provider.size(); ++i) {
       const AutocompleteResultsForProviderMojo& result_by_provider =
           *result->results_by_provider[i];
       for (size_t j = 0; j < result_by_provider.results.size(); ++j) {
         result_by_provider.results[j]->starred = bookmark_model->IsBookmarked(
             GURL(result_by_provider.results[j]->destination_url));
       }
     }
   }
 
-  page_->HandleNewAutocompleteResult(result.Pass());
+  page_->HandleNewAutocompleteResult(std::move(result));
 }
 
 bool OmniboxUIHandler::LookupIsTypedHost(const base::string16& host,
                                          bool* is_typed_host) const {
   history::HistoryService* const history_service =
       HistoryServiceFactory::GetForProfile(profile_,
                                            ServiceAccessType::EXPLICIT_ACCESS);
   if (!history_service)
     return false;
   history::URLDatabase* url_db = history_service->InMemoryDatabase();
   if (!url_db)
     return false;
   *is_typed_host = url_db->IsTypedHost(base::UTF16ToUTF8(host));
   return true;
 }
 
 void OmniboxUIHandler::StartOmniboxQuery(const mojo::String& input_string,
                                          int32_t cursor_position,
                                          bool prevent_inline_autocomplete,
                                          bool prefer_keyword,
                                          int32_t page_classification,
                                          OmniboxPagePtr page) {
   // Reset the controller.  If we don't do this, then the
   // AutocompleteController might inappropriately set its |minimal_changes|
   // variable (or something else) and some providers will short-circuit
   // important logic and return stale results.  In short, we want the
   // actual results to not depend on the state of the previous request.
   ResetController();
-  page_ = page.Pass();
+  page_ = std::move(page);
   time_omnibox_started_ = base::Time::Now();
   input_ = AutocompleteInput(
       input_string.To<base::string16>(), cursor_position, std::string(), GURL(),
       static_cast<metrics::OmniboxEventProto::PageClassification>(
           page_classification),
       prevent_inline_autocomplete, prefer_keyword, true, true, false,
       ChromeAutocompleteSchemeClassifier(profile_));
   controller_->Start(input_);
 }
 
 void OmniboxUIHandler::ResetController() {
   controller_.reset(new AutocompleteController(
       make_scoped_ptr(new ChromeAutocompleteProviderClient(profile_)), this,
       AutocompleteClassifier::kDefaultOmniboxProviders));
 }