Mojo C++ bindings: make chrome/browser/ui/webui mojom target use STL types.

chrome/browser/ui/webui/omnibox/omnibox_page_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_page_handler.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 46 matching lines @@
     }
     return array;
   }
 };
 
 template <>
 struct TypeConverter<mojom::AutocompleteMatchPtr, AutocompleteMatch> {
   static mojom::AutocompleteMatchPtr Convert(const AutocompleteMatch& input) {
     mojom::AutocompleteMatchPtr result(mojom::AutocompleteMatch::New());
     if (input.provider != NULL) {
-      result->provider_name = input.provider->GetName();
+      result->provider_name = std::string(input.provider->GetName());
       result->provider_done = input.provider->done();
     }
     result->relevance = input.relevance;
     result->deletable = input.deletable;
-    result->fill_into_edit = mojo::String::From(input.fill_into_edit);
+    result->fill_into_edit = base::UTF16ToUTF8(input.fill_into_edit);
     result->inline_autocompletion =
-        mojo::String::From(input.inline_autocompletion);
+        base::UTF16ToUTF8(input.inline_autocompletion);
     result->destination_url = input.destination_url.spec();
-    result->contents = mojo::String::From(input.contents);
+    result->contents = base::UTF16ToUTF8(input.contents);
     // At this time, we're not bothering to send along the long vector that
     // represent contents classification.  i.e., for each character, what
     // type of text it is.
-    result->description = mojo::String::From(input.description);
+    result->description = base::UTF16ToUTF8(input.description);
     // At this time, we're not bothering to send along the long vector that
     // represents description classification.  i.e., for each character, what
     // type of text it is.
     result->transition = input.transition;
     result->allowed_to_be_default_match = input.allowed_to_be_default_match;
     result->type = AutocompleteMatchType::ToString(input.type);
     if (input.associated_keyword.get() != NULL) {
       result->associated_keyword =
-          mojo::String::From(input.associated_keyword->keyword);
+          base::UTF16ToUTF8(input.associated_keyword->keyword);
     }
-    result->keyword = mojo::String::From(input.keyword);
+    result->keyword = base::UTF16ToUTF8(input.keyword);
     result->duplicates = static_cast<int32_t>(input.duplicate_matches.size());
     result->from_previous = input.from_previous;
 
     result->additional_info =
         mojo::Array<mojom::AutocompleteAdditionalInfoPtr>::From(
-            input.additional_info);
+            input.additional_info)
+            .PassStorage();
     return result;
   }
 };
 
 template <>
 struct TypeConverter<mojom::AutocompleteResultsForProviderPtr,
                      scoped_refptr<AutocompleteProvider>> {
   static mojom::AutocompleteResultsForProviderPtr Convert(
       const scoped_refptr<AutocompleteProvider>& input) {
     mojom::AutocompleteResultsForProviderPtr result(
         mojom::AutocompleteResultsForProvider::New());
     result->provider_name = input->GetName();
     result->results =
-        mojo::Array<mojom::AutocompleteMatchPtr>::From(input->matches());
+        mojo::Array<mojom::AutocompleteMatchPtr>::From(input->matches())
+            .PassStorage();
     return result;
   }
 };
 
 }  // namespace mojo
 
 OmniboxPageHandler::OmniboxPageHandler(
     Profile* profile,
     mojo::InterfaceRequest<mojom::OmniboxPageHandler> request)
     : profile_(profile), binding_(this, std::move(request)) {
   ResetController();
 }
 
 OmniboxPageHandler::~OmniboxPageHandler() {}
 
 void OmniboxPageHandler::OnResultChanged(bool default_match_changed) {
   mojom::OmniboxResultPtr result(mojom::OmniboxResult::New());
   result->done = controller_->done();
   result->time_since_omnibox_started_ms =
       (base::Time::Now() - time_omnibox_started_).InMilliseconds();
   const base::string16 host =
       input_.text().substr(input_.parts().host.begin, input_.parts().host.len);
-  result->host = mojo::String::From(host);
+  result->host = base::UTF16ToUTF8(host);
   bool is_typed_host;
   if (!LookupIsTypedHost(host, &is_typed_host))
     is_typed_host = false;
   result->is_typed_host = is_typed_host;
 
   {
     // Copy to an ACMatches to make conversion easier. Since this isn't
     // performance critical we don't worry about the cost here.
     ACMatches matches(controller_->result().begin(),
                       controller_->result().end());
     result->combined_results =
-        mojo::Array<mojom::AutocompleteMatchPtr>::From(matches);
+        mojo::Array<mojom::AutocompleteMatchPtr>::From(matches).PassStorage();
   }
   result->results_by_provider =
       mojo::Array<mojom::AutocompleteResultsForProviderPtr>::From(
-          controller_->providers());
+          controller_->providers())
+          .PassStorage();
 
   // Fill AutocompleteMatch::starred.
   BookmarkModel* bookmark_model =
       BookmarkModelFactory::GetForBrowserContext(profile_);
   if (bookmark_model) {
     for (size_t i = 0; i < result->combined_results.size(); ++i) {
       result->combined_results[i]->starred = bookmark_model->IsBookmarked(
-          GURL(result->combined_results[i]->destination_url.get()));
+          GURL(result->combined_results[i]->destination_url));
     }
     for (size_t i = 0; i < result->results_by_provider.size(); ++i) {
       const mojom::AutocompleteResultsForProvider& 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.get()));
+            GURL(result_by_provider.results[j]->destination_url));
       }
     }
   }
 
   page_->HandleNewAutocompleteResult(std::move(result));
 }
 
 bool OmniboxPageHandler::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 OmniboxPageHandler::SetClientPage(mojom::OmniboxPagePtr page) {
   page_ = std::move(page);
 }
 
-void OmniboxPageHandler::StartOmniboxQuery(const mojo::String& input_string,
+void OmniboxPageHandler::StartOmniboxQuery(const std::string& input_string,
                                            int32_t cursor_position,
                                            bool prevent_inline_autocomplete,
                                            bool prefer_keyword,
                                            int32_t page_classification) {
   // 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();
   time_omnibox_started_ = base::Time::Now();
   input_ = AutocompleteInput(
-      input_string.To<base::string16>(), cursor_position, std::string(), GURL(),
+      base::UTF8ToUTF16(input_string), 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 OmniboxPageHandler::ResetController() {
   controller_.reset(new AutocompleteController(
       base::MakeUnique<ChromeAutocompleteProviderClient>(profile_), this,
       AutocompleteClassifier::kDefaultOmniboxProviders));
 }