Add a static Google Doodle to the experimental app list start page.

chrome/browser/ui/app_list/start_page_service.cc

 // Copyright 2013 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 "chrome/browser/ui/app_list/start_page_service.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/json/json_string_value_serializer.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/user_metrics.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/google/google_profile_helper.h"
 #include "chrome/browser/media/media_stream_infobar_delegate.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/hotword_service.h"
 #include "chrome/browser/search/hotword_service_factory.h"
 #include "chrome/browser/ui/app_list/speech_auth_helper.h"
 #include "chrome/browser/ui/app_list/speech_recognizer.h"
 #include "chrome/browser/ui/app_list/start_page_observer.h"
 #include "chrome/browser/ui/app_list/start_page_service_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
+#include "components/google/core/browser/google_util.h"
 #include "components/ui/zoom/zoom_controller.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/speech_recognition_session_preamble.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "extensions/browser/extension_system_provider.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/common/extension.h"
+#include "net/base/load_flags.h"
 #include "net/base/network_change_notifier.h"
+#include "net/url_request/url_fetcher.h"
 #include "ui/app_list/app_list_switches.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/audio/cras_audio_handler.h"
 #endif
 
 using base::RecordAction;
 using base::UserMetricsAction;
 
 namespace app_list {
 
 namespace {
 
+// Path to google.com's doodle JSON.
+const char kDoodleJsonPath[] = "async/ddljson";
+
+// Delay between checking for a new doodle when no doodle is found.
+const int kDefaultDoodleRecheckDelayMinutes = 30;
+
 bool InSpeechRecognition(SpeechRecognitionState state) {
   return state == SPEECH_RECOGNITION_RECOGNIZING ||
       state == SPEECH_RECOGNITION_IN_SPEECH;
 }
 
+GURL GetGoogleBaseURL(Profile* profile) {
+  GURL base_url(google_util::CommandLineGoogleBaseURL());
+  if (!base_url.is_valid())
+    base_url = google_profile_helper::GetGoogleHomePageURL(profile);
+
+  return base_url;
+}
+
 }  // namespace
 
 class StartPageService::ProfileDestroyObserver
     : public content::NotificationObserver {
  public:
   explicit ProfileDestroyObserver(StartPageService* service)
       : service_(service) {
     registrar_.Add(this,
                    chrome::NOTIFICATION_PROFILE_DESTROYED,
                    content::Source<Profile>(service_->profile()));
@@ skipping 396 matching lines @@
 void StartPageService::WebUILoaded() {
   // There's a race condition between the WebUI loading, and calling its JS
   // functions. Specifically, calling LoadContents() doesn't mean that the page
   // has loaded, but several code paths make this assumption. This function
   // allows us to defer calling JS functions until after the page has finished
   // loading.
   webui_finished_loading_ = true;
   for (const auto& cb : pending_webui_callbacks_)
     cb.Run();
   pending_webui_callbacks_.clear();
+
+  FetchDoodleJson();
 }
 
 void StartPageService::LoadContents() {
   contents_.reset(content::WebContents::Create(
       content::WebContents::CreateParams(profile_)));
   contents_delegate_.reset(new StartPageWebContentsDelegate());
   contents_->SetDelegate(contents_delegate_.get());
 
   // The ZoomController needs to be created before the web contents is observed
   // by this object. Otherwise it will react to DidNavigateMainFrame after this
   // object does, resetting the zoom mode in the process.
   ui_zoom::ZoomController::CreateForWebContents(contents_.get());
   Observe(contents_.get());
 
   contents_->GetController().LoadURL(
       GURL(chrome::kChromeUIAppListStartPageURL),
       content::Referrer(),
       ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
       std::string());
 }
 
 void StartPageService::UnloadContents() {
   contents_.reset();
   webui_finished_loading_ = false;
 }
 
+void StartPageService::FetchDoodleJson() {
+  // SetPathStr() requires its argument to stay in scope as long as
+  // |replacements| is, so a std::string is needed, instead of a char*.
+  std::string path = kDoodleJsonPath;
+  GURL::Replacements replacements;
+  replacements.SetPathStr(path);
+
+  GURL doodle_url = GetGoogleBaseURL(profile_).ReplaceComponents(replacements);
+  doodle_fetcher_.reset(
+      net::URLFetcher::Create(0, doodle_url, net::URLFetcher::GET, this));
+  doodle_fetcher_->SetRequestContext(profile_->GetRequestContext());
+  doodle_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES);
+  doodle_fetcher_->Start();
+}
+
+void StartPageService::OnURLFetchComplete(const net::URLFetcher* source) {
+  std::string json_data;
+  source->GetResponseAsString(&json_data);
+
+  // Remove XSSI guard for JSON parsing.
+  size_t json_start_index = json_data.find("{");
+  if (json_start_index != std::string::npos)
+    json_data.erase(0, json_start_index);
+
+  JSONStringValueSerializer deserializer(json_data);
+  deserializer.set_allow_trailing_comma(true);
+  int error_code = 0;
+  scoped_ptr<base::Value> doodle_json(
+      deserializer.Deserialize(&error_code, nullptr));
+
+  base::TimeDelta recheck_delay =
+      base::TimeDelta::FromMinutes(kDefaultDoodleRecheckDelayMinutes);
+
+  if (error_code == 0) {
+    base::DictionaryValue* doodle_dictionary = nullptr;
+    // Use the supplied TTL as the recheck delay if available.
+    if (doodle_json->GetAsDictionary(&doodle_dictionary)) {
+      int time_to_live = 0;
+      if (doodle_dictionary->GetInteger("ddljson.time_to_live_ms",
+                                        &time_to_live)) {
+        recheck_delay = base::TimeDelta::FromMilliseconds(time_to_live);
+      }
+    }
+
+    contents_->GetWebUI()->CallJavascriptFunction(
+        "appList.startPage.onAppListDoodleUpdated", *doodle_json,
+        base::StringValue(GetGoogleBaseURL(profile_).spec()));
+  }
+
+  // Check for a new doodle.
+  content::BrowserThread::PostDelayedTask(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(&StartPageService::FetchDoodleJson,
+                 weak_factory_.GetWeakPtr()),
+      recheck_delay);
+}
+
 }  // namespace app_list