Introduce a Doodle Fetcher for NTP

components/doodle/doodle_fetcher.h

+// Copyright 2017 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_DOODLE_DOODLE_FETCHER_H_
+#define COMPONENTS_DOODLE_DOODLE_FETCHER_H_
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "base/callback.h"
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "base/optional.h"
+#include "net/url_request/url_fetcher_delegate.h"
+#include "url/gurl.h"
+
+class GoogleURLTracker;
+
+namespace base {
+class Clock;
+class DictionaryValue;
+class Value;
+}
+
+namespace net {
+class URLRequestContextGetter;
+}
+
+namespace doodle {
+
+enum class DoodleState {
+  AVAILABLE,
+  NO_DOODLE,
+  DOWNLOAD_ERROR,
+  PARSING_ERROR,
+};
+
+enum class DoodleType {
+  UNKNOWN,
+  SIMPLE,
+  RANDOM,
+  VIDEO,
+  INTERACTIVE,
+  INLINE_INTERACTIVE,
+  SLIDESHOW,
+};
+
+// Information about a Doodle image. If the image is invalid, the |url| will be
+// empty and invalid. By default the dimensions are 0.
+struct DoodleImage {
+  DoodleImage();
+  explicit DoodleImage(GURL url);

[sdefresne, 2017/02/13 15:55:26]

Two questions:

1. why is this taking GURL by copy and not by const-reference?
2. this appears to not be implemented in doodle_fetcher.cc, should it be
removed?

[fhorschig, 2017/02/13 17:25:51]

Removed the unnecessary constructor.

+  ~DoodleImage();
+
+  GURL url;
+  int height;
+  int width;
+  bool is_animated_gif;
+  bool is_cta;
+
+  // Copying and assignment allowed.
+};
+
+// All information about a current doodle that can be fetched from the remote
+// end. By default, all URLs are empty and therefore invalid.
+struct DoodleConfig {
+  DoodleConfig();
+  DoodleConfig(const DoodleConfig& config);  // = default;
+  ~DoodleConfig();
+
+  DoodleType doodle_type;
+  std::string alt_text;
+  std::string interactive_html;
+
+  base::Time expiry_date;
+  GURL search_url;
+  GURL target_url;
+  GURL fullpage_interactive_url;
+
+  DoodleImage large_image;
+  DoodleImage large_cta_image;
+  DoodleImage transparent_large_image;
+};
+
+// This class provides information about any recent doodle.
+// It works asynchronously and calls a callback when finished fetching the
+// information from the remote enpoint.
+class DoodleFetcher : public net::URLFetcherDelegate {
+ public:
+  // Callback that is invoked when the fetching is done.
+  // |doodle_config| will only contain a value if |state| is AVAILABLE.
+  using FinishedCallback = base::OnceCallback<void(
+      DoodleState state,
+      const base::Optional<DoodleConfig>& doodle_config)>;
+  // Callback for JSON parsing to allow injecting platform-dependent code.
+  using ParseJSONCallback = base::Callback<void(
+      const std::string& unsafe_json,
+      const base::Callback<void(std::unique_ptr<base::Value> json)>& success,
+      const base::Callback<void(const std::string&)>& error)>;
+
+  DoodleFetcher(net::URLRequestContextGetter* download_context,
+                GoogleURLTracker* google_url_tracker,
+                const ParseJSONCallback& json_parsing_callback);
+  ~DoodleFetcher() override;
+
+  // Fetches a doodle asynchronously. The |callback| is called with a
+  // DoodleState indicating whether the request succeded in fetching a doodle.
+  // If a fetch is already running, the callback will be queued and invoked with
+  // result from the next completed request.
+  void FetchDoodle(FinishedCallback callback);
+
+  // Overrides internal clock for testing purposes.
+  void SetClockForTesting(std::unique_ptr<base::Clock> clock) {
+    clock_ = std::move(clock);
+  }
+
+ private:
+  // net::URLFetcherDelegate implementation.
+  void OnURLFetchComplete(const net::URLFetcher* source) override;
+
+  // ParseJSONCallback Success callback
+  void OnJsonParsed(std::unique_ptr<base::Value> json);
+  // ParseJSONCallback Failure callback
+  void OnJsonParseFailed(const std::string& error_message);
+
+  base::Optional<DoodleConfig> ParseDoodle(
+      const base::DictionaryValue& ddljson) const;
+  bool ParseImage(const base::DictionaryValue& image_dict,
+                  const std::string& image_name,
+                  DoodleImage* image) const;
+  void ParseBaseInformation(const base::DictionaryValue& ddljson,
+                            DoodleConfig* config) const;
+  GURL ParseRelativeUrl(const base::DictionaryValue& dict_value,
+                        const std::string& key) const;
+
+  void RespondToAllCallbacks(DoodleState state,
+                             const base::Optional<DoodleConfig>& config);
+  GURL GetGoogleBaseUrl() const;
+
+  // Returns whether a fetch is still in progress. A fetch begins when a
+  // callback is added and ends when the last callback was called.
+  bool IsFetchInProgress() const { return !callbacks_.empty(); }
+
+  // Parameters set from constructor.
+  net::URLRequestContextGetter* const download_context_;
+  ParseJSONCallback json_parsing_callback_;
+  GoogleURLTracker* google_url_tracker_;
+
+  // Allow for an injectable tick clock for testing.
+  std::unique_ptr<base::Clock> clock_;
+
+  std::vector<FinishedCallback> callbacks_;
+  std::unique_ptr<net::URLFetcher> fetcher_;
+
+  base::WeakPtrFactory<DoodleFetcher> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(DoodleFetcher);
+};
+
+}  // namespace doodle
+
+#endif  // COMPONENTS_DOODLE_DOODLE_FETCHER_H_