Add AffiliationFetcher to fetch authoritative affiliation information regarding facets.

components/password_manager/core/browser/affiliation_fetcher.h

+// Copyright 2014 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_PASSWORD_MANAGER_CORE_BROWSER_AFFILIATION_FETCHER_H_
+#define COMPONENTS_PASSWORD_MANAGER_CORE_BROWSER_AFFILIATION_FETCHER_H_
+
+#include <vector>
+
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "components/password_manager/core/browser/affiliation_fetcher_delegate.h"
+#include "components/password_manager/core/browser/affiliation_utils.h"
+#include "net/url_request/url_fetcher_delegate.h"
+
+class GURL;
+
+namespace net {
+class URLRequestContextGetter;
+}  // namespace net
+
+namespace password_manager {
+
+// Fetches authoritative information regarding which facets are affiliated with
+// each other, that is, which facets belong to the same logical application.
+// See affiliation_utils.h for a definition of what this means.
+//
+// An instance is good for exactly one fetch, and may be used from any thread,

[Randy Smith (Not in Mondays), 2014/12/10 22:13:24]

Strictly speaking, not any thread; the URLFetcher can only be used from
non-worker pools because there needs to be a "real thread" to post notifications
back to.  See https://code.google.com/p/chromium/issues/detail?id=432307#c5.  

[engedy, 2014/12/11 20:49:24]

Rephrased, but I did not want to be overly verbose. Let me know if I you'd
rather I added more detail to the comment.

[Randy Smith (Not in Mondays), 2014/12/11 20:54:35]

I'd prefer you just said "and may be used from any thread that runs a message
loop (i.e. not a worker pool thread)."  "Not thread-safe" doesn't really have a
lot of information in it; very little chromium code is actually thread safe.

[engedy, 2014/12/12 14:06:12]

Sounds good, thanks for the proposal. Done.

+// but is not thread-safe.
+class AffiliationFetcher : net::URLFetcherDelegate {
+ public:
+  ~AffiliationFetcher() override;
+
+  // Constructs a fetcher to retrieve affiliations for each facet in |facet_ids|
+  // using the specified |request_context_getter|, and will provide the results
+  // to the |delegate| on the same thread that creates the instance.
+  static AffiliationFetcher* Create(

[Garrett Casto, 2014/12/11 08:18:39]

Out of curiosity, any particular reason for the factory pattern here?

[engedy, 2014/12/11 20:49:24]

I am going to add a way to insert a custom factory for testing in the next CL. I
wanted to avoid the repetitive task of refactoring all the test just for the
sake of being able to remove the factory method.

+      net::URLRequestContextGetter* request_context_getter,
+      const std::vector<FacetURI>& facet_uris,
+      AffiliationFetcherDelegate* delegate);
+
+  // Actually starts the request, and will call the delegate with the results on
+  // the same thread when done. If |this| is destroyed before completion, the
+  // in-flight request is cancelled, and the delegate will not be called.
+  // Further details:
+  //   * No cookies are sent/saved with the request.
+  //   * In case of network/server errors, the request will not be retried.
+  //   * Results are guaranteed to be always fresh and will never be cached.
+  virtual void StartRequest();
+
+  const std::vector<FacetURI>& requested_facet_uris() const {
+    return requested_facet_uris_;
+  }
+
+  AffiliationFetcherDelegate* delegate() const { return delegate_; }
+
+ protected:
+  AffiliationFetcher(net::URLRequestContextGetter* request_context_getter,
+                     const std::vector<FacetURI>& facet_uris,
+                     AffiliationFetcherDelegate* delegate);
+
+ private:
+  // Builds the URL for the affiliation API's lookup method.
+  GURL BuildQueryURL() const;
+
+  // Prepares and returns the serialized form of the JSON dictionary that will
+  // be the payload of the POST request.
+  std::string PreparePayload() const;
+
+  // Parses the server response into |result| and returns true on success. We
+  // gracefully ignore most unknown fields in the response, so this method will
+  // return false only if the response is gravely ill-formed.
+  bool ParseResponse(AffiliationFetcherDelegate::Result* result) const;
+
+  // net::URLFetcherDelegate:
+  void OnURLFetchComplete(const net::URLFetcher* source) override;
+
+  const scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
+  const std::vector<FacetURI> requested_facet_uris_;
+  AffiliationFetcherDelegate* const delegate_;
+
+  scoped_ptr<net::URLFetcher> fetcher_;
+
+  DISALLOW_COPY_AND_ASSIGN(AffiliationFetcher);
+};
+
+}  // namespace password_manager
+
+#endif  // COMPONENTS_PASSWORD_MANAGER_CORE_BROWSER_AFFILIATION_FETCHER_H_