[Passwords] AffiliationFetcher - Groupings support.

This change creates a struct AffiliationFetcherDelegate::Result to support both affiliations and groupings.

Bug: 1108279
Change-Id: I0b02ba3dc606204c9b8e5a25394a7e9cab02eb3d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2357809
Commit-Queue: Nela Kaczmarek <nelakaczmarek@google.com>
Reviewed-by: Vasilii Sukhanov <vasilii@chromium.org>
Reviewed-by: Jan Wilken Dörrie <jdoerrie@chromium.org>
Cr-Commit-Position: refs/heads/master@{#799174}

components/password_manager/core/browser/BUILD.gn

@@ -43,6 +43,7 @@ static_library("browser") {
     "android_affiliation/affiliation_fetch_throttler_delegate.h",
     "android_affiliation/affiliation_fetcher.cc",
     "android_affiliation/affiliation_fetcher.h",
+    "android_affiliation/affiliation_fetcher_delegate.cc",
     "android_affiliation/affiliation_fetcher_delegate.h",
     "android_affiliation/affiliation_fetcher_interface.h",
     "android_affiliation/android_affiliation_service.cc",

components/password_manager/core/browser/android_affiliation/affiliation_backend.cc

@@ -181,7 +181,7 @@ void AffiliationBackend::OnFetchSucceeded(
   fetcher_.reset();
   throttler_->InformOfNetworkRequestComplete(true);
 
-  for (const AffiliatedFacets& affiliated_facets : *result) {
+  for (const AffiliatedFacets& affiliated_facets : result->affiliations) {
     AffiliatedFacetsWithUpdateTime affiliation;
     affiliation.facets = affiliated_facets;
     affiliation.last_update_time = clock_->Now();

components/password_manager/core/browser/android_affiliation/affiliation_fetcher_delegate.cc

+
+// Copyright 2020 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/password_manager/core/browser/android_affiliation/affiliation_fetcher_delegate.h"
+
+namespace password_manager {
+
+AffiliationFetcherDelegate::Result::Result() = default;
+
+AffiliationFetcherDelegate::Result::Result(const Result& other) = default;
+
+AffiliationFetcherDelegate::Result::Result(Result&& other) = default;
+
+AffiliationFetcherDelegate::Result&
+AffiliationFetcherDelegate::Result::operator=(const Result& other) = default;
+
+AffiliationFetcherDelegate::Result&
+AffiliationFetcherDelegate::Result::operator=(Result&& other) = default;
+
+AffiliationFetcherDelegate::Result::~Result() = default;
+
+}  // namespace password_manager

components/password_manager/core/browser/android_affiliation/affiliation_fetcher_delegate.h

@@ -17,7 +17,18 @@ namespace password_manager {
 class AffiliationFetcherDelegate {
  public:
   // Encapsulates the response to an affiliations request.
-  typedef std::vector<AffiliatedFacets> Result;
+  struct Result {
+    // copyable and movable
+    Result();
+    Result(const Result& other);
+    Result(Result&& other);
+    Result& operator=(const Result& other);
+    Result& operator=(Result&& other);
+    ~Result();
+
+    std::vector<AffiliatedFacets> affiliations;
+    std::vector<GroupedFacets> groupings;
+  };
 
   // Called when affiliation information has been successfully retrieved. The
   // |result| will contain at most as many equivalence class as facet URIs in

components/password_manager/core/browser/android_affiliation/affiliation_fetcher_unittest.cc

@@ -47,6 +47,12 @@ class MockAffiliationFetcherDelegate
   }
 
   const Result& result() const { return *result_; }
+  const std::vector<AffiliatedFacets>& affiliations() const {
+    return result_->affiliations;
+  }
+  const std::vector<GroupedFacets>& groupings() const {
+    return result_->groupings;
+  }
 
  private:
   std::unique_ptr<Result> result_;
@@ -154,14 +160,14 @@ TEST_F(AffiliationFetcherTest, BasicReqestAndResponse) {
   ASSERT_NO_FATAL_FAILURE(VerifyRequestPayload(requested_uris));
   ASSERT_TRUE(testing::Mock::VerifyAndClearExpectations(&mock_delegate));
 
-  ASSERT_EQ(2u, mock_delegate.result().size());
-  EXPECT_THAT(mock_delegate.result()[0],
+  ASSERT_EQ(2u, mock_delegate.affiliations().size());
+  EXPECT_THAT(mock_delegate.affiliations()[0],
               testing::UnorderedElementsAre(
                   Facet{FacetURI::FromCanonicalSpec(kExampleWebFacet1URI)},
                   Facet{FacetURI::FromCanonicalSpec(kExampleWebFacet2URI)},
                   Facet{FacetURI::FromCanonicalSpec(kExampleAndroidFacetURI)}));
   EXPECT_THAT(
-      mock_delegate.result()[1],
+      mock_delegate.affiliations()[1],
       testing::UnorderedElementsAre(
           Facet{FacetURI::FromCanonicalSpec(kNotExampleWebFacetURI)},
           Facet{FacetURI::FromCanonicalSpec(kNotExampleAndroidFacetURI)}));
@@ -193,8 +199,8 @@ TEST_F(AffiliationFetcherTest, AndroidBrandingInfoIsReturnedIfPresent) {
   ASSERT_NO_FATAL_FAILURE(VerifyRequestPayload(requested_uris));
   ASSERT_TRUE(testing::Mock::VerifyAndClearExpectations(&mock_delegate));
 
-  ASSERT_EQ(1u, mock_delegate.result().size());
-  EXPECT_THAT(mock_delegate.result()[0],
+  ASSERT_EQ(1u, mock_delegate.affiliations().size());
+  EXPECT_THAT(mock_delegate.affiliations()[0],
               testing::UnorderedElementsAre(
                   Facet{FacetURI::FromCanonicalSpec(kExampleWebFacet1URI)},
                   Facet{FacetURI::FromCanonicalSpec(kExampleWebFacet2URI)},
@@ -224,8 +230,8 @@ TEST_F(AffiliationFetcherTest, MissingEquivalenceClassesAreCreated) {
   ASSERT_NO_FATAL_FAILURE(VerifyRequestPayload(requested_uris));
   ASSERT_TRUE(testing::Mock::VerifyAndClearExpectations(&mock_delegate));
 
-  ASSERT_EQ(1u, mock_delegate.result().size());
-  EXPECT_THAT(mock_delegate.result()[0],
+  ASSERT_EQ(1u, mock_delegate.affiliations().size());
+  EXPECT_THAT(mock_delegate.affiliations()[0],
               testing::UnorderedElementsAre(
                   Facet{FacetURI::FromCanonicalSpec(kExampleWebFacet1URI)}));
 }
@@ -254,8 +260,8 @@ TEST_F(AffiliationFetcherTest, DuplicateEquivalenceClassesAreIgnored) {
 
   ASSERT_TRUE(testing::Mock::VerifyAndClearExpectations(&mock_delegate));
 
-  ASSERT_EQ(1u, mock_delegate.result().size());
-  EXPECT_THAT(mock_delegate.result()[0],
+  ASSERT_EQ(1u, mock_delegate.affiliations().size());
+  EXPECT_THAT(mock_delegate.affiliations()[0],
               testing::UnorderedElementsAre(
                   Facet{FacetURI::FromCanonicalSpec(kExampleWebFacet1URI)},
                   Facet{FacetURI::FromCanonicalSpec(kExampleWebFacet2URI)},
@@ -282,8 +288,8 @@ TEST_F(AffiliationFetcherTest, EmptyEquivalenceClassesAreIgnored) {
 
   ASSERT_TRUE(testing::Mock::VerifyAndClearExpectations(&mock_delegate));
 
-  ASSERT_EQ(1u, mock_delegate.result().size());
-  EXPECT_THAT(mock_delegate.result()[0],
+  ASSERT_EQ(1u, mock_delegate.affiliations().size());
+  EXPECT_THAT(mock_delegate.affiliations()[0],
               testing::UnorderedElementsAre(
                   Facet{FacetURI::FromCanonicalSpec(kExampleWebFacet1URI)}));
 }
@@ -314,8 +320,8 @@ TEST_F(AffiliationFetcherTest, UnrecognizedFacetURIsAreIgnored) {
 
   ASSERT_TRUE(testing::Mock::VerifyAndClearExpectations(&mock_delegate));
 
-  ASSERT_EQ(1u, mock_delegate.result().size());
-  EXPECT_THAT(mock_delegate.result()[0],
+  ASSERT_EQ(1u, mock_delegate.affiliations().size());
+  EXPECT_THAT(mock_delegate.affiliations()[0],
               testing::UnorderedElementsAre(
                   Facet{FacetURI::FromCanonicalSpec(kExampleWebFacet1URI)},
                   Facet{FacetURI::FromCanonicalSpec(kExampleWebFacet2URI)},

components/password_manager/core/browser/android_affiliation/affiliation_utils.cc

@@ -265,7 +265,6 @@ FacetURI::FacetURI(const std::string& canonical_spec, bool is_valid)
                         &parsed_);
 }
 
-
 // AffiliatedFacetsWithUpdateTime ---------------------------------------------
 
 AffiliatedFacetsWithUpdateTime::AffiliatedFacetsWithUpdateTime() = default;
@@ -273,6 +272,15 @@ AffiliatedFacetsWithUpdateTime::AffiliatedFacetsWithUpdateTime() = default;
 AffiliatedFacetsWithUpdateTime::AffiliatedFacetsWithUpdateTime(
     const AffiliatedFacetsWithUpdateTime& other) = default;
 
+AffiliatedFacetsWithUpdateTime::AffiliatedFacetsWithUpdateTime(
+    AffiliatedFacetsWithUpdateTime&& other) = default;
+
+AffiliatedFacetsWithUpdateTime& AffiliatedFacetsWithUpdateTime::operator=(
+    const AffiliatedFacetsWithUpdateTime& other) = default;
+
+AffiliatedFacetsWithUpdateTime& AffiliatedFacetsWithUpdateTime::operator=(
+    AffiliatedFacetsWithUpdateTime&& other) = default;
+
 AffiliatedFacetsWithUpdateTime::~AffiliatedFacetsWithUpdateTime() = default;
 
 // Helpers --------------------------------------------------------------------

components/password_manager/core/browser/android_affiliation/affiliation_utils.h

@@ -174,7 +174,10 @@ struct Facet {
 };
 
 // A collection of facets affiliated with each other, i.e. an equivalence class.
-typedef std::vector<Facet> AffiliatedFacets;
+using AffiliatedFacets = std::vector<Facet>;
+
+// A collection of grouped facets.
+using GroupedFacets = std::vector<Facet>;
 
 // A collection of facets affiliated with each other, i.e. an equivalence class,
 // plus a timestamp that indicates the last time the data was updated from an
@@ -182,6 +185,11 @@ typedef std::vector<Facet> AffiliatedFacets;
 struct AffiliatedFacetsWithUpdateTime {
   AffiliatedFacetsWithUpdateTime();
   AffiliatedFacetsWithUpdateTime(const AffiliatedFacetsWithUpdateTime& other);
+  AffiliatedFacetsWithUpdateTime(AffiliatedFacetsWithUpdateTime&& other);
+  AffiliatedFacetsWithUpdateTime& operator=(
+      const AffiliatedFacetsWithUpdateTime& other);
+  AffiliatedFacetsWithUpdateTime& operator=(
+      AffiliatedFacetsWithUpdateTime&& other);
   ~AffiliatedFacetsWithUpdateTime();
 
   AffiliatedFacets facets;

components/password_manager/core/browser/android_affiliation/fake_affiliation_api.cc

@@ -57,7 +57,7 @@ void ScopedFakeAffiliationAPI::ServeNextRequest() {
       }
     }
     if (had_intersection_with_request)
-      fake_response->push_back(preset_equivalence_class);
+      fake_response->affiliations.push_back(preset_equivalence_class);
   }
   fetcher->SimulateSuccess(std::move(fake_response));
 }

components/password_manager/core/browser/android_affiliation/lookup_affiliation_response_parser.cc

@@ -10,7 +10,7 @@ bool ParseLookupAffiliationResponse(
     const std::vector<FacetURI>& requested_facet_uris,
     const affiliation_pb::LookupAffiliationResponse& response,
     AffiliationFetcherDelegate::Result* result) {
-  result->reserve(requested_facet_uris.size());
+  result->affiliations.reserve(requested_facet_uris.size());
 
   std::map<FacetURI, size_t> facet_uri_to_class_index;
   for (int i = 0; i < response.affiliation_size(); ++i) {
@@ -39,7 +39,7 @@ bool ParseLookupAffiliationResponse(
     // affiliations must form an equivalence relation.
     for (const Facet& facet : affiliated_facets) {
       if (!facet_uri_to_class_index.count(facet.uri))
-        facet_uri_to_class_index[facet.uri] = result->size();
+        facet_uri_to_class_index[facet.uri] = result->affiliations.size();
       if (facet_uri_to_class_index[facet.uri] !=
           facet_uri_to_class_index[affiliated_facets[0].uri]) {
         return false;
@@ -47,15 +47,17 @@ bool ParseLookupAffiliationResponse(
     }
 
     // Filter out duplicate equivalence classes in the response.
-    if (facet_uri_to_class_index[affiliated_facets[0].uri] == result->size())
-      result->push_back(affiliated_facets);
+    if (facet_uri_to_class_index[affiliated_facets[0].uri] ==
+        result->affiliations.size()) {
+      result->affiliations.push_back(affiliated_facets);
+    }
   }
 
   // Synthesize an equivalence class (of size one) for each facet that did not
   // appear in the server response due to not being affiliated with any others.
   for (const FacetURI& uri : requested_facet_uris) {
     if (!facet_uri_to_class_index.count(uri))
-      result->push_back({{uri}});
+      result->affiliations.push_back({{uri}});
   }
 
   return true;