[Doodle] Introduce a DoodleService

components/doodle/doodle_fetcher_impl.cc

 // 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.
 
 #include "components/doodle/doodle_fetcher_impl.h"
 
 #include <utility>
 
 #include "base/strings/string_number_conversions.h"
-#include "base/time/clock.h"
 #include "base/time/default_clock.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/google/core/browser/google_url_tracker.h"
 #include "components/google/core/browser/google_util.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 
@@ skipping 102 matching lines @@
                              base::Bind(&DoodleFetcherImpl::OnJsonParsed,
                                         weak_ptr_factory_.GetWeakPtr()),
                              base::Bind(&DoodleFetcherImpl::OnJsonParseFailed,
                                         weak_ptr_factory_.GetWeakPtr()));
 }
 
 void DoodleFetcherImpl::OnJsonParsed(std::unique_ptr<base::Value> json) {
   std::unique_ptr<base::DictionaryValue> config =
       base::DictionaryValue::From(std::move(json));
   if (!config.get()) {
-    DLOG(WARNING) << "Doodle JSON is not valid";
+    DLOG(WARNING) << "Doodle JSON is not valid.";
     RespondToAllCallbacks(DoodleState::PARSING_ERROR, base::nullopt);
     return;
   }
 
   const base::DictionaryValue* ddljson = nullptr;
   if (!config->GetDictionary("ddljson", &ddljson)) {
-    DLOG(WARNING) << "Doodle JSON reponse did not contain 'ddljson' key.";
+    DLOG(WARNING) << "Doodle JSON response did not contain 'ddljson' key.";
     RespondToAllCallbacks(DoodleState::PARSING_ERROR, base::nullopt);
     return;
   }
 
   base::Optional<DoodleConfig> doodle = ParseDoodle(*ddljson);
   if (!doodle.has_value()) {
     RespondToAllCallbacks(DoodleState::NO_DOODLE, base::nullopt);
     return;
   }
 
   RespondToAllCallbacks(DoodleState::AVAILABLE, std::move(doodle));
 }
 
 void DoodleFetcherImpl::OnJsonParseFailed(const std::string& error_message) {
   DLOG(WARNING) << "JSON parsing failed: " << error_message;
   RespondToAllCallbacks(DoodleState::PARSING_ERROR, base::nullopt);
 }
 
 base::Optional<DoodleConfig> DoodleFetcherImpl::ParseDoodle(
     const base::DictionaryValue& ddljson) const {
   DoodleConfig doodle;
+  // The |large_image| field is required (it's the "default" representation for
+  // the doodle).
   if (!ParseImage(ddljson, "large_image", &doodle.large_image)) {
     return base::nullopt;
   }
   ParseImage(ddljson, "transparent_large_image",
              &doodle.transparent_large_image);
   ParseImage(ddljson, "large_cta_image", &doodle.large_cta_image);
   ParseBaseInformation(ddljson, &doodle);
   return doodle;
 }
 
@@ skipping 64 matching lines @@
 
 GURL DoodleFetcherImpl::GetGoogleBaseUrl() const {
   GURL cmd_line_url = google_util::CommandLineGoogleBaseURL();
   if (cmd_line_url.is_valid()) {
     return cmd_line_url;
   }
   return google_url_tracker_->google_url();
 }
 
 }  // namespace doodle