When the user signs in, make sure to set cookies on all reachable google

google_apis/gaia/merge_session_helper.cc

 // 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.
 
 #include "google_apis/gaia/merge_session_helper.h"
 
+#include <vector>
+
+#include "base/json/json_reader.h"
+#include "base/stl_util.h"
+#include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
+#include "base/time/time.h"
+#include "base/values.h"
 #include "google_apis/gaia/gaia_auth_fetcher.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "google_apis/gaia/oauth2_token_service.h"
+#include "net/base/load_flags.h"
+#include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 
+MergeSessionHelper::ExternalCcResultFetcher::ExternalCcResultFetcher(
+    MergeSessionHelper* helper) : helper_(helper) {
+  DCHECK(helper_);
+}
+
+MergeSessionHelper::ExternalCcResultFetcher::~ExternalCcResultFetcher() {
+  CleanupTransientState();
+}
+
+std::string MergeSessionHelper::ExternalCcResultFetcher::GetExternalCcResult() {
+  std::vector<std::string> results;
+  for (ResultMap::const_iterator it = results_.begin(); it != results_.end();
+       ++it) {
+    results.push_back(it->first + ":" + it->second);
+  }
+  return JoinString(results, ",");
+}
+
+void MergeSessionHelper::ExternalCcResultFetcher::Start() {
+  CleanupTransientState();
+  results_.clear();
+  gaia_auth_fetcher_.reset(
+      new GaiaAuthFetcher(this, GaiaConstants::kChromeSource,
+                          helper_->request_context()));
+  gaia_auth_fetcher_->StartGetCheckConnectionInfo();
+}
+
+void
+MergeSessionHelper::ExternalCcResultFetcher::OnGetCheckConnectionInfoSuccess(
+    const std::string& data) {
+  base::Value* value = base::JSONReader::Read(data);
+  const base::ListValue* list;
+  if (!value || !value->GetAsList(&list))
+    return;
+
+  // Start a fetcher for each connection URL that needs to be checked.
+  for (size_t i = 0; i < list->GetSize(); ++i) {
+    const base::DictionaryValue* dict;
+    if (list->GetDictionary(i, &dict)) {
+      std::string token;
+      std::string url;
+      if (dict->GetString("carryBackToken", &token) &&
+          dict->GetString("url", &url)) {
+        results_[token] = "null";
+        net::URLFetcher* fetcher = CreateFetcher(GURL(url));
+        fetchers_[fetcher->GetOriginalURL()] = std::make_pair(token, fetcher);
+        fetcher->Start();
+      }
+    }
+  }
+
+  // Some fetches may timeout.  Start a timer to decide when the result fetcher
+  // has waited long enough.
+  // TODO(rogerta): I have no idea how to long to wait before timing out.

[guohui, 2014/08/05 19:14:07]

nits: extra to

[Roger Tawa OOO till Jul 10th, 2014/08/08 19:29:53]

Done.

+  // Gaia folks say this should take no more than 2 second even in mobile.
+  // This will need to be tweaked.
+  timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(5),
+               this, &MergeSessionHelper::ExternalCcResultFetcher::Timeout);
+}
+
+net::URLFetcher* MergeSessionHelper::ExternalCcResultFetcher::CreateFetcher(
+    const GURL& url) {
+  net::URLFetcher* fetcher = net::URLFetcher::Create(
+      0,
+      url,
+      net::URLFetcher::GET,
+      this);
+  fetcher->SetRequestContext(helper_->request_context());
+  fetcher->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
+                        net::LOAD_DO_NOT_SAVE_COOKIES);
+
+  // Fetchers are sometimes cancelled because a network change was detected,
+  // especially at startup and after sign-in on ChromeOS.
+  fetcher->SetAutomaticallyRetryOnNetworkChanges(1);
+  return fetcher;
+}
+
+void MergeSessionHelper::ExternalCcResultFetcher::OnURLFetchComplete(
+    const net::URLFetcher* source) {
+  const GURL& url = source->GetOriginalURL();
+  const net::URLRequestStatus& status = source->GetStatus();
+  int response_code = source->GetResponseCode();
+  if (status.is_success() && response_code == net::HTTP_OK &&
+      fetchers_.count(url) > 0) {
+    std::string data;
+    source->GetResponseAsString(&data);
+    // Only up to the first 16 characters of the response are important.
+    // Truncate if needed.
+    if (data.size() > 16)
+      data.resize(16);
+    results_[fetchers_[url].first] = data;
+
+    // If we have received all the responses we expect, cancel the timer and
+    // report the result.
+    DCHECK_EQ(source, fetchers_[url].second);
+    fetchers_.erase(url);
+    delete source;
+    if (fetchers_.size() == 0) {
+      timer_.Stop();
+      CleanupTransientState();
+    }
+  }
+}
+
+void MergeSessionHelper::ExternalCcResultFetcher::Timeout() {
+  CleanupTransientState();
+}
+
+void MergeSessionHelper::ExternalCcResultFetcher::CleanupTransientState() {
+  gaia_auth_fetcher_.reset();
+
+  for (URLToTokenAndFetcher::const_iterator it = fetchers_.begin();
+       it != fetchers_.end(); ++it) {
+    delete it->second.second;
+  }
+  fetchers_.clear();
+}
+
+
 MergeSessionHelper::MergeSessionHelper(
     OAuth2TokenService* token_service,
     net::URLRequestContextGetter* request_context,
     Observer* observer)
     : token_service_(token_service),
-      request_context_(request_context) {
+      request_context_(request_context),
+      result_fetcher_(this) {
   if (observer)
     AddObserver(observer);
 }
 
 MergeSessionHelper::~MergeSessionHelper() {
   DCHECK(accounts_.empty());
 }
 
 void MergeSessionHelper::LogIn(const std::string& account_id) {
   DCHECK(!account_id.empty());
@@ skipping 74 matching lines @@
 void MergeSessionHelper::SignalComplete(
     const std::string& account_id,
     const GoogleServiceAuthError& error) {
   // Its possible for the observer to delete |this| object.  Don't access
   // access any members after this calling the observer.  This method should
   // be the last call in any other method.
   FOR_EACH_OBSERVER(Observer, observer_list_,
                     MergeSessionCompleted(account_id, error));
 }
 
+void MergeSessionHelper::StartFetchingExternalCcResult() {
+  result_fetcher_.Start();
+}
+
 void MergeSessionHelper::StartLogOutUrlFetch() {
   DCHECK(accounts_.front().empty());
   VLOG(1) << "MergeSessionHelper::StartLogOutUrlFetch";
   GURL logout_url(GaiaUrls::GetInstance()->service_logout_url());
   net::URLFetcher* fetcher =
       net::URLFetcher::Create(logout_url, net::URLFetcher::GET, this);
   fetcher->SetRequestContext(request_context_);
   fetcher->Start();
 }
 
 void MergeSessionHelper::OnUbertokenSuccess(const std::string& uber_token) {
   VLOG(1) << "MergeSessionHelper::OnUbertokenSuccess"
           << " account=" << accounts_.front();
   gaia_auth_fetcher_.reset(new GaiaAuthFetcher(this,
                                                GaiaConstants::kChromeSource,
                                                request_context_));
-  gaia_auth_fetcher_->StartMergeSession(uber_token);
+  gaia_auth_fetcher_->StartMergeSession(uber_token,
+                                        result_fetcher_.GetExternalCcResult());

[guohui, 2014/08/05 19:14:07]

is it guaranteed that all eternal cc results are available at this point?

[guohui, 2014/08/06 20:52:27]

could you also add comments here that it is not guaranteed that the external cc
result is fully available at this point?

[Roger Tawa OOO till Jul 10th, 2014/08/08 19:29:53]

Nope.  We don't want to delay the merge session, so any that have responded will
be included, any that haven't will not.  For checks that have not completed, the
worst case is that the user sees a "sign in" button.  If they click that button,
they will be signed in automatically, no need to retype username or password.

[Roger Tawa OOO till Jul 10th, 2014/08/08 19:29:53]

Done.

 }
 
 void MergeSessionHelper::OnUbertokenFailure(
     const GoogleServiceAuthError& error) {
   VLOG(1) << "Failed to retrieve ubertoken"
           << " account=" << accounts_.front()
           << " error=" << error.ToString();
   const std::string account_id = accounts_.front();
   HandleNextAccount();
   SignalComplete(account_id, error);
@@ skipping 39 matching lines @@
     VLOG(1) << "MergeSessionHelper::HandleNextAccount: no more";
     uber_token_fetcher_.reset();
   } else {
     if (accounts_.front().empty()) {
       StartLogOutUrlFetch();
     } else {
       StartFetching();
     }
   }
 }