[Autofill] Switch on use_new_wrapper_types mode.

components/autofill/content/renderer/autofill_agent.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 "components/autofill/content/renderer/autofill_agent.h"
 
 #include <stddef.h>
 
 #include <tuple>
 
@@ skipping 24 matching lines @@
 #include "components/autofill/core/common/form_data_predictions.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/autofill/core/common/password_form_fill_data.h"
 #include "components/autofill/core/common/save_password_progress_logger.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/ssl_status.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
-#include "mojo/common/common_type_converters.h"
 #include "net/cert/cert_status_flags.h"
 #include "services/shell/public/cpp/interface_provider.h"
 #include "services/shell/public/cpp/interface_registry.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/web/WebConsoleMessage.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElementCollection.h"
 #include "third_party/WebKit/public/web/WebFormControlElement.h"
 #include "third_party/WebKit/public/web/WebFormElement.h"
@@ skipping 451 matching lines @@
   form_util::PreviewForm(form, element_);
 
   GetAutofillDriver()->DidPreviewAutofillFormData();
 }
 
 void AutofillAgent::OnPing() {
   GetAutofillDriver()->PingAck();
 }
 
 void AutofillAgent::FieldTypePredictionsAvailable(
-    mojo::Array<FormDataPredictions> forms) {
+    const std::vector<FormDataPredictions>& forms) {
   for (const auto& form : forms) {
     form_cache_.ShowPredictions(form);
   }
 }
 
 void AutofillAgent::ClearForm() {
   form_cache_.ClearFormWithElement(element_);
 }
 
 void AutofillAgent::ClearPreviewedForm() {
   if (!element_.isNull()) {
     if (password_autofill_agent_->DidClearAutofillSelection(element_))
       return;
 
     form_util::ClearPreviewedFormWithElement(element_,
                                              was_query_node_autofilled_);
   } else {
     // TODO(isherman): There seem to be rare cases where this code *is*
     // reachable: see [ http://crbug.com/96321#c6 ].  Ideally we would
     // understand those cases and fix the code to avoid them.  However, so far I
     // have been unable to reproduce such a case locally.  If you hit this
     // NOTREACHED(), please file a bug against me.
     NOTREACHED();
   }
 }
 
-void AutofillAgent::FillFieldWithValue(const mojo::String& value) {
+void AutofillAgent::FillFieldWithValue(const std::string& value) {
   WebInputElement* input_element = toWebInputElement(&element_);
   if (input_element) {
-    DoFillFieldWithValue(value.To<base::string16>(), input_element);
+    DoFillFieldWithValue(base::UTF8ToUTF16(value), input_element);
     input_element->setAutofilled(true);
   }
 }
 
-void AutofillAgent::PreviewFieldWithValue(const mojo::String& value) {
+void AutofillAgent::PreviewFieldWithValue(const std::string& value) {
   WebInputElement* input_element = toWebInputElement(&element_);
   if (input_element)
-    DoPreviewFieldWithValue(value.To<base::string16>(), input_element);
+    DoPreviewFieldWithValue(base::UTF8ToUTF16(value), input_element);
 }
 
-void AutofillAgent::AcceptDataListSuggestion(const mojo::String& value) {
-  DoAcceptDataListSuggestion(value.To<base::string16>());
+void AutofillAgent::AcceptDataListSuggestion(const std::string& value) {
+  DoAcceptDataListSuggestion(base::UTF8ToUTF16(value));
 }
 
-void AutofillAgent::FillPasswordSuggestion(const mojo::String& username,
-                                           const mojo::String& password) {
+void AutofillAgent::FillPasswordSuggestion(const std::string& username,
+                                           const std::string& password) {
   bool handled = password_autofill_agent_->FillSuggestion(
-      element_, username.To<base::string16>(), password.To<base::string16>());
+      element_, base::UTF8ToUTF16(username), base::UTF8ToUTF16(password));
   DCHECK(handled);
 }
 
-void AutofillAgent::PreviewPasswordSuggestion(const mojo::String& username,
-                                              const mojo::String& password) {
+void AutofillAgent::PreviewPasswordSuggestion(const std::string& username,
+                                              const std::string& password) {
   bool handled = password_autofill_agent_->PreviewSuggestion(
-      element_, username.To<base::string16>(), password.To<base::string16>());
+      element_, base::UTF8ToUTF16(username), base::UTF8ToUTF16(password));
   DCHECK(handled);
 }
 
 void AutofillAgent::ShowInitialPasswordAccountSuggestions(
     int32_t key,
     const PasswordFormFillData& form_data) {
   std::vector<blink::WebInputElement> elements;
   std::unique_ptr<RendererSavePasswordProgressLogger> logger;
   if (password_autofill_agent_->logging_state_active()) {
     logger.reset(new RendererSavePasswordProgressLogger(this, routing_id()));
@@ skipping 145 matching lines @@
     // Find the datalist values and send them to the browser process.
     GetDataListSuggestions(*input_element,
                            &data_list_values,
                            &data_list_labels);
     TrimStringVectorForIPC(&data_list_values);
     TrimStringVectorForIPC(&data_list_labels);
   }
 
   is_popup_possibly_visible_ = true;
 
-  GetAutofillDriver()->SetDataList(
-      mojo::Array<mojo::String>::From(data_list_values),
-      mojo::Array<mojo::String>::From(data_list_labels));
+  std::vector<std::string> values;

[yzshen1, 2016/07/26 16:45:36]

Please reserve space.

[leonhsl(Using Gerrit), 2016/07/27 02:50:26]

Acknowledged.

[leonhsl(Using Gerrit), 2016/07/27 09:25:32]

Done. Use base::string16 typemap now, removed these conversion codes.

+  for (auto& i : data_list_values)
+    values.emplace_back(base::UTF16ToUTF8(i));
+  std::vector<std::string> labels;
+  for (auto& i : data_list_labels)
+    labels.emplace_back(base::UTF16ToUTF8(i));
+  GetAutofillDriver()->SetDataList(values, labels);
   GetAutofillDriver()->QueryFormFieldAutofill(
       autofill_query_id_, form, field,
       render_frame()->GetRenderView()->ElementBoundsInWindow(element_));
 }
 
 void AutofillAgent::DoFillFieldWithValue(const base::string16& value,
                                          WebInputElement* node) {
   base::AutoReset<bool> auto_reset(&ignore_text_changes_, true);
   node->setEditingValue(value.substr(0, node->maxLength()));
 }
 
 void AutofillAgent::DoPreviewFieldWithValue(const base::string16& value,
                                             WebInputElement* node) {
   was_query_node_autofilled_ = element_.isAutofilled();
   node->setSuggestedValue(value.substr(0, node->maxLength()));
   node->setAutofilled(true);
   form_util::PreviewSuggestion(node->suggestedValue(), node->value(), node);
 }
 
 void AutofillAgent::ProcessForms() {
   // Record timestamp of when the forms are first seen. This is used to
   // measure the overhead of the Autofill feature.
   base::TimeTicks forms_seen_timestamp = base::TimeTicks::Now();
 
   WebLocalFrame* frame = render_frame()->GetWebFrame();
   std::vector<FormData> forms = form_cache_.ExtractNewForms();
 
   // Always communicate to browser process for topmost frame.
   if (!forms.empty() || !frame->parent()) {
-    GetAutofillDriver()->FormsSeen(std::move(forms), forms_seen_timestamp);
+    GetAutofillDriver()->FormsSeen(forms, forms_seen_timestamp);
   }
 }
 
 void AutofillAgent::HidePopup() {
   if (!is_popup_possibly_visible_)
     return;
   is_popup_possibly_visible_ = false;
   is_generation_popup_possibly_visible_ = false;
 
   GetAutofillDriver()->HidePopup();
@@ skipping 52 matching lines @@
 void AutofillAgent::LegacyAutofillAgent::OnDestruct() {
   // No-op. Don't delete |this|.
 }
 
 void AutofillAgent::LegacyAutofillAgent::FocusChangeComplete() {
   if (agent_)
     agent_->FocusChangeComplete();
 }
 
 }  // namespace autofill