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 <list>
+#include <memory>
+#include <string>
+#include <utility>
+
+#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);
+  ~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;
+
+  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.
+  // If no information could be fetched, the reason is stored in |state|.
+  using FinishedCallback =
+      base::OnceCallback<void(DoodleState state,
+                              base::Optional<DoodleConfig> doodle_config)>;
+  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,
+                ParseJSONCallback json_parsing_callback);

[Marc Treib, 2017/02/01 11:53:14]

nit: Pass by const ref

[fhorschig, 2017/02/03 13:21:05]

Done.

+  DoodleFetcher(DoodleFetcher&&);
+  ~DoodleFetcher() override;
+
+  // Fetches a doodle asynchronously. The |callback| is always called and
+  // provides a valid DoodleConfig object.

[Marc Treib, 2017/02/01 11:53:14]

This is now kinda outdated.

[fhorschig, 2017/02/03 13:21:04]

Updated.

+  // If a fetch is already running,

[Marc Treib, 2017/02/01 11:53:14]

...? :)

[fhorschig, 2017/02/03 13:21:05]

Looks like an urgent lunch break ...
Added the rest.

+  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);
+
+  void ParseDoodle(std::unique_ptr<base::DictionaryValue> config);
+  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,
+                             base::Optional<DoodleConfig> config);
+  GURL GetGoogleBaseUrl() const;
+
+  // Parameter set from constructor.

[Marc Treib, 2017/02/01 11:53:14]

nitty nit: Parameters, plural :)

[fhorschig, 2017/02/03 13:21:04]

Wow, I should really look at my comments more closely.

+  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::list<FinishedCallback> callbacks_;

[Marc Treib, 2017/02/01 11:53:14]

nit: I'd just use a vector. Rule of thumb: Don't use list unless you have a good
reason for it.

[fhorschig, 2017/02/03 13:21:05]

Done.

+  std::unique_ptr<net::URLFetcher> fetcher_;
+
+  base::WeakPtrFactory<DoodleFetcher> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(DoodleFetcher);
+};
+
+extern const char kDoodleConfigPath[];
+
+}  // namespace doodle
+
+#endif  // COMPONENTS_DOODLE_DOODLE_FETCHER_H_