Made a proto bridge to parse between legacy api and new api protos. This will be

needed by the download manager to handle the new api to reuse most of the
logic in place for the legacy api.

Change-Id: I529a55781919ddb8c23b3cebc9f1b1d0af148af6
Reviewed-on: https://chromium-review.googlesource.com/c/1334268
Commit-Queue: Vincent Boisselle <vincb@chromium.org>
Reviewed-by: Roger McFarlane <rogerm@chromium.org>
Cr-Commit-Position: refs/heads/master@{#609768}

components/autofill/core/browser/BUILD.gn

@@ -498,6 +498,7 @@ source_set("unit_tests") {
     "phone_field_unittest.cc",
     "phone_number_i18n_unittest.cc",
     "phone_number_unittest.cc",
+    "proto/legacy_proto_bridge_unittest.cc",
     "randomized_encoder_unittest.cc",
     "rationalization_util_unittest.cc",
     "region_combobox_model_unittest.cc",
@@ -536,6 +537,7 @@ source_set("unit_tests") {
     ":password_generator_fips181",
     ":test_support",
     ":unit_tests_bundle_data",
+    "proto:legacy_proto_bridge",
     "//base",
     "//base/test:test_support",
     "//components/autofill/core/common",

components/autofill/core/browser/proto/BUILD.gn

@@ -14,3 +14,13 @@ fuzzable_proto_library("proto") {
     "strike_data.proto",
   ]
 }
+
+static_library("legacy_proto_bridge") {
+  sources = [
+    "legacy_proto_bridge.cc",
+    "legacy_proto_bridge.h",
+  ]
+  deps = [
+    ":proto",
+  ]
+}

components/autofill/core/browser/proto/api_v1.proto

@@ -68,7 +68,7 @@ message AutofillQueryResponse {
       // Signature identifying the field that is the same as in the request.
       optional fixed32 field_signature = 1;
       // The predicted field type.
-      optional int32 primary_type_prediction = 2;
+      optional fixed32 primary_type_prediction = 2;
       // Detailed list of all possible predictions (including
       // |primary_type_prediction| as the first item).
       repeated FieldPrediction predictions = 3;

components/autofill/core/browser/proto/legacy_proto_bridge.cc

+// Copyright 2018 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/core/browser/proto/legacy_proto_bridge.h"
+
+namespace autofill {
+
+namespace {
+
+AutofillPageQueryRequest::Form::Field CreateLegacyFieldFromApiField(
+    const AutofillQueryContents::Form::Field& legacy_field) {
+  AutofillPageQueryRequest::Form::Field api_field;
+  api_field.set_signature(legacy_field.signature());
+  api_field.set_name(legacy_field.name());
+  api_field.set_control_type(legacy_field.type());
+  return api_field;
+}
+
+AutofillPageQueryRequest::Form CreateApiFormFromLegacyForm(
+    const AutofillQueryContents::Form& legacy_form) {
+  AutofillPageQueryRequest::Form api_form;
+  for (const auto& legacy_field : legacy_form.field()) {
+    *api_form.add_fields() = CreateLegacyFieldFromApiField(legacy_field);
+  }
+  return api_form;
+}
+
+AutofillQueryResponseContents::Field::FieldPrediction
+CreateLegacyFieldPredictionFromApiPrediction(
+    const AutofillQueryResponse::FormSuggestion::FieldSuggestion::
+        FieldPrediction& api_field_prediction) {
+  AutofillQueryResponseContents::Field::FieldPrediction legacy_prediction;
+  legacy_prediction.set_type(api_field_prediction.type());
+  return legacy_prediction;
+}
+
+AutofillQueryResponseContents::Field CreateLegacyFieldFromApiField(
+    const AutofillQueryResponse::FormSuggestion::FieldSuggestion& api_field) {
+  AutofillQueryResponseContents::Field legacy_field;
+  legacy_field.set_overall_type_prediction(api_field.primary_type_prediction());
+  for (const auto& api_prediction : api_field.predictions()) {
+    *legacy_field.add_predictions() =
+        CreateLegacyFieldPredictionFromApiPrediction(api_prediction);
+  }
+  *legacy_field.mutable_password_requirements() =
+      api_field.password_requirements();
+  return legacy_field;
+}
+
+}  // namespace
+
+AutofillPageQueryRequest CreateApiRequestFromLegacyRequest(
+    const AutofillQueryContents& legacy_request) {
+  AutofillPageQueryRequest api_request;
+  api_request.set_client_version(legacy_request.client_version());
+  for (const auto& legacy_form : legacy_request.form()) {
+    *api_request.add_forms() = CreateApiFormFromLegacyForm(legacy_form);
+  }
+  return api_request;
+}
+
+AutofillQueryResponseContents CreateLegacyResponseFromApiResponse(
+    const AutofillQueryResponse& api_response) {
+  AutofillQueryResponseContents legacy_response;
+  for (const auto& api_form : api_response.form_suggestions()) {
+    for (const auto& api_field : api_form.field_suggestions()) {
+      *legacy_response.add_field() = CreateLegacyFieldFromApiField(api_field);
+    }
+  }
+  return legacy_response;
+}
+
+}  // namespace autofill

components/autofill/core/browser/proto/legacy_proto_bridge.h

+// Copyright 2018 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.
+
+#ifndef COMPONENTS_AUTOFILL_CORE_BROWSER_PROTO_LEGACY_PROTO_BRIDGE_H_
+#define COMPONENTS_AUTOFILL_CORE_BROWSER_PROTO_LEGACY_PROTO_BRIDGE_H_
+
+#include "components/autofill/core/browser/proto/api_v1.pb.h"
+#include "components/autofill/core/browser/proto/server.pb.h"
+
+namespace autofill {
+
+// Creates a new API request from a legacy request.
+autofill::AutofillPageQueryRequest CreateApiRequestFromLegacyRequest(
+    const AutofillQueryContents& legacy_request);
+
+// Creates a new API response from a legacy response.
+AutofillQueryResponseContents CreateLegacyResponseFromApiResponse(
+    const autofill::AutofillQueryResponse& api_response);
+
+}  // namespace autofill
+
+#endif  // COMPONENTS_AUTOFILL_CORE_BROWSER_PROTO_LEGACY_PROTO_BRIDGE_H_

components/autofill/core/browser/proto/legacy_proto_bridge_unittest.cc

+// Copyright 2018 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/core/browser/proto/legacy_proto_bridge.h"
+
+#include "components/autofill/core/browser/proto/api_v1.pb.h"
+#include "components/autofill/core/browser/proto/password_requirements.pb.h"
+#include "components/autofill/core/browser/proto/server.pb.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace autofill {
+namespace {
+
+using ::testing::ElementsAre;
+using ::testing::Eq;
+using ::testing::Property;
+
+AutofillQueryContents::Form::Field MakeLegacyField(uint32_t signature,
+                                                   const std::string& name,
+                                                   const std::string& type) {
+  AutofillQueryContents::Form::Field field;
+  field.set_signature(signature);
+  field.set_name(name);
+  field.set_type(type);
+  return field;
+}
+
+AutofillQueryResponse::FormSuggestion::FieldSuggestion MakeFieldSuggestion(
+    uint32_t field_signature,
+    uint32_t primary_type_prediction,
+    std::vector<uint32_t> predictions,
+    bool may_use_prefilled_placeholder,
+    PasswordRequirementsSpec password_requirements) {
+  AutofillQueryResponse::FormSuggestion::FieldSuggestion field_suggestion;
+  field_suggestion.set_field_signature(field_signature);
+  field_suggestion.set_primary_type_prediction(primary_type_prediction);
+  for (auto prediction : predictions) {
+    field_suggestion.add_predictions()->set_type(prediction);
+  }
+  field_suggestion.set_may_use_prefilled_placeholder(
+      may_use_prefilled_placeholder);
+  *field_suggestion.mutable_password_requirements() =
+      std::move(password_requirements);
+  return field_suggestion;
+}
+
+TEST(ProtoBridgeTest, TestCreateApiRequestFromLegacyRequest) {
+  AutofillQueryContents legacy_request;
+  legacy_request.set_client_version("dummy client v1");
+  AutofillQueryContents::Form* new_form = legacy_request.add_form();
+  new_form->set_signature(1234U);
+  *new_form->add_field() = MakeLegacyField(1234U, "First Name", "text");
+  *new_form->add_field() = MakeLegacyField(5678U, "Last Name", "text");
+
+  new_form = legacy_request.add_form();
+  new_form->set_signature(5678U);
+  *new_form->add_field() = MakeLegacyField(1234U, "Street Address", "text");
+  *new_form->add_field() = MakeLegacyField(5678U, "Zip Code", "text");
+
+  AutofillPageQueryRequest api_request =
+      CreateApiRequestFromLegacyRequest(legacy_request);
+
+  EXPECT_EQ(api_request.client_version(), "dummy client v1");
+  // Assert fields of form 0.
+  EXPECT_EQ(api_request.forms(0).fields(0).signature(), 1234U);
+  EXPECT_EQ(api_request.forms(0).fields(0).name(), "First Name");
+  EXPECT_EQ(api_request.forms(0).fields(0).control_type(), "text");
+  EXPECT_EQ(api_request.forms(0).fields(1).signature(), 5678U);
+  EXPECT_EQ(api_request.forms(0).fields(1).name(), "Last Name");
+  EXPECT_EQ(api_request.forms(0).fields(1).control_type(), "text");
+  // Assert field of form 1.
+  EXPECT_EQ(api_request.forms(1).fields(0).signature(), 1234U);
+  EXPECT_EQ(api_request.forms(1).fields(0).name(), "Street Address");
+  EXPECT_EQ(api_request.forms(1).fields(0).control_type(), "text");
+  EXPECT_EQ(api_request.forms(1).fields(1).signature(), 5678U);
+  EXPECT_EQ(api_request.forms(1).fields(1).name(), "Zip Code");
+  EXPECT_EQ(api_request.forms(1).fields(1).control_type(), "text");
+}
+
+TEST(ProtoBridgeTest, CreateLegacyResponseFromApiResponse) {
+  constexpr uint32_t dummy_password_type = 1U;
+  constexpr uint32_t dummy_address_type = 2U;
+  constexpr uint32_t dummy_password_priority = 3U;
+
+  PasswordRequirementsSpec dummy_password_requirement_specs;
+  dummy_password_requirement_specs.set_priority(dummy_password_priority);
+
+  AutofillQueryResponse api_response;
+  // Add suggestions for form 0.
+  auto* form_suggestion = api_response.add_form_suggestions();
+  *form_suggestion->add_field_suggestions() = MakeFieldSuggestion(
+      /*field_signature=*/1234U,
+      /*primary_type_prediction=*/dummy_password_type,
+      /*predictions=*/{dummy_password_type, dummy_address_type},
+      /*may_use_prefilled_placeholder=*/true,
+      /*password_requirements=*/dummy_password_requirement_specs);
+  // Add suggestions for form 1.
+  form_suggestion = api_response.add_form_suggestions();
+  *form_suggestion->add_field_suggestions() = MakeFieldSuggestion(
+      /*field_signature=*/5678U, /*primary_type_prediction=*/dummy_address_type,
+      /*predictions=*/{dummy_address_type, dummy_password_type},
+      /*may_use_prefilled_placeholder=*/false,
+      /*password_requirements=*/dummy_password_requirement_specs);
+
+  AutofillQueryResponseContents legacy_response =
+      CreateLegacyResponseFromApiResponse(api_response);
+
+  // Assert fields of form 0 in legacy response.
+  EXPECT_EQ(legacy_response.field(0).overall_type_prediction(),
+            dummy_password_type);
+  EXPECT_THAT(
+      legacy_response.field(0).predictions(),
+      ElementsAre(
+          Property(&AutofillQueryResponseContents::Field::FieldPrediction::type,
+                   Eq(dummy_password_type)),
+          Property(&AutofillQueryResponseContents::Field::FieldPrediction::type,
+                   Eq(dummy_address_type))));
+  EXPECT_THAT(legacy_response.field(0).password_requirements(),
+              Property(&PasswordRequirementsSpec::priority,
+                       Eq(dummy_password_priority)));
+
+  // Assert fields of form 1 in legacy response.
+  EXPECT_EQ(legacy_response.field(1).overall_type_prediction(),
+            dummy_address_type);
+  EXPECT_THAT(
+      legacy_response.field(1).predictions(),
+      ElementsAre(
+          Property(&AutofillQueryResponseContents::Field::FieldPrediction::type,
+                   Eq(dummy_address_type)),
+          Property(&AutofillQueryResponseContents::Field::FieldPrediction::type,
+                   Eq(dummy_password_type))));
+  EXPECT_THAT(legacy_response.field(1).password_requirements(),
+              Property(&PasswordRequirementsSpec::priority,
+                       Eq(dummy_password_priority)));
+}
+
+}  // namespace
+}  // namespace autofill