Integrate invalidation API into ChromeToMobileService.

chrome/browser/chrome_to_mobile_service.cc

 // Copyright (c) 2012 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/chrome_to_mobile_service.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/guid.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
-#include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
-#include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_url.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/token_service.h"
 #include "chrome/browser/signin/token_service_factory.h"
+#include "chrome/browser/sync/profile_sync_service.h"
+#include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_command_controller.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/cloud_print/cloud_print_helpers.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/net/gaia/gaia_urls.h"
 #include "chrome/common/net/gaia/oauth2_access_token_fetcher.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
+#include "google/cacheinvalidation/include/types.h"
+#include "google/cacheinvalidation/types.pb.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
+#include "sync/notifier/invalidation_util.h"
 
 namespace {
 
 // The default enabled/disabled state of the Chrome To Mobile feature.
 const bool kChromeToMobileEnabled = true;
 
 // The maximum number of retries for the URLFetcher requests.
 const size_t kMaxRetries = 1;
 
 // The number of hours to delay before retrying authentication on failure.
 const size_t kAuthRetryDelayHours = 6;
 
 // The number of hours before subsequent search requests are allowed.
 // This value is used to throttle expensive cloud print search requests.
 // Note that this limitation does not hold across application restarts.
 const int kSearchRequestDelayHours = 24;
 
+// The sync invalidation object ID for Chrome to Mobile's mobile device list.
+// This corresponds with cloud print's server-side invalidation object ID.
+// Meaning: "U" == "User", "CM" == "Chrome to Mobile", "MLST" == "Mobile LiST".
+const char kSyncInvalidationObjectIdChromeToMobileDeviceList[] = "UCMMLST";
+
 // The cloud print OAuth2 scope and 'printer' type of compatible mobile devices.
 const char kCloudPrintAuth[] = "https://www.googleapis.com/auth/cloudprint";
 const char kTypeAndroid[] = "ANDROID_CHROME_SNAPSHOT";
 const char kTypeIOS[] = "IOS_CHROME_SNAPSHOT";
 
-// The account info URL pattern and strings to check for cloud print access.
-// The 'key=' query parameter is used for caching; supply a random number.
-// The 'rv=2' query parameter requests a JSON response; use 'rv=1' for XML.
-const char kAccountInfoURL[] =
-    "https://clients1.google.com/tbproxy/getaccountinfo?key=%s&rv=2&%s";
-const char kAccountServicesKey[] = "services";
-const char kCloudPrintSerivceValue[] = "cprt";
-
 // The Chrome To Mobile requestor type; used by services for filtering.
 const char kChromeToMobileRequestor[] = "requestor=chrome-to-mobile";
 
 // Get the job type string for a cloud print job submission.
 std::string GetType(const ChromeToMobileService::JobData& data) {
   if (data.type == ChromeToMobileService::URL)
     return "url";
   if (data.type == ChromeToMobileService::DELAYED_SNAPSHOT)
     return "url_with_delayed_snapshot";
   DCHECK_EQ(data.type, ChromeToMobileService::SNAPSHOT);
@@ skipping 88 matching lines @@
   if (command_line->HasSwitch(switches::kEnableChromeToMobile))
     return true;
 
   return kChromeToMobileEnabled;
 }
 
 // static
 void ChromeToMobileService::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterListPref(prefs::kChromeToMobileDeviceList,
                           PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterInt64Pref(prefs::kChromeToMobileTimestamp, 0,
-                           PrefService::UNSYNCABLE_PREF);
 }
 
 ChromeToMobileService::ChromeToMobileService(Profile* profile)
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
       profile_(profile),
-      cloud_print_url_(new CloudPrintURL(profile)),
-      cloud_print_accessible_(false) {
-  // TODO(msw): Fix GMock tests, which lack profiles (http://crbug.com/122183).
-  if (profile_) {
-    // Get an access token as soon as the Gaia login refresh token is available.
-    TokenService* service = TokenServiceFactory::GetForProfile(profile_);
-    registrar_.Add(this, chrome::NOTIFICATION_TOKEN_AVAILABLE,
-                   content::Source<TokenService>(service));
-    if (service->HasOAuthLoginToken())
-      RequestAccessToken();
-  }
+      sync_invalidation_enabled_(false),
+      cloud_print_url_(new CloudPrintURL(profile)) {
+  RegisterForDeviceListInvalidations();
 }
 
 ChromeToMobileService::~ChromeToMobileService() {
   while (!snapshots_.empty())
     DeleteSnapshot(*snapshots_.begin());
+  if (profile_) {
+    ProfileSyncServiceFactory::GetForProfile(profile_)->
+        UnregisterInvalidationHandler(this);
+  }
 }
 
 bool ChromeToMobileService::HasMobiles() const {
-  return !GetMobiles()->empty();
+  return sync_invalidation_enabled_ && !GetMobiles()->empty();
 }
 
 const base::ListValue* ChromeToMobileService::GetMobiles() const {
-  return profile_->GetPrefs()->GetList(prefs::kChromeToMobileDeviceList);
-}
-
-void ChromeToMobileService::RequestMobileListUpdate() {
-  if (access_token_.empty())
-    RequestAccessToken();
-  else if (cloud_print_accessible_)
-    RequestDeviceSearch();
+  return sync_invalidation_enabled_ ?
+      profile_->GetPrefs()->GetList(prefs::kChromeToMobileDeviceList) : NULL;
 }
 
 void ChromeToMobileService::GenerateSnapshot(Browser* browser,
                                              base::WeakPtr<Observer> observer) {
   // Callback SnapshotFileCreated from CreateSnapshotFile to continue.
   CreateSnapshotFileCallback callback =
       base::Bind(&ChromeToMobileService::SnapshotFileCreated,
                  weak_ptr_factory_.GetWeakPtr(), observer,
                  browser->session_id().id());
   // Create a temporary file via the blocking pool for snapshot storage.
   if (!content::BrowserThread::PostBlockingPoolTask(FROM_HERE,
           base::Bind(&CreateSnapshotFile, callback))) {
     NOTREACHED();
   }
 }
 
-void ChromeToMobileService::SendToMobile(const base::DictionaryValue& mobile,
+void ChromeToMobileService::SendToMobile(const base::DictionaryValue* mobile,
                                          const FilePath& snapshot,
                                          Browser* browser,
                                          base::WeakPtr<Observer> observer) {
+  if (access_token_.empty()) {
+    // Enqueue this task to perform after obtaining an access token.
+    task_queue_.push(base::Bind(&ChromeToMobileService::SendToMobile,
+        weak_ptr_factory_.GetWeakPtr(), base::Owned(mobile->DeepCopy()),
+        snapshot, browser, observer));
+    RequestAccessToken();
+    return;
+  }
+
   LogMetric(SENDING_URL);
 
   JobData data;
   std::string mobile_os;
-  if (!mobile.GetString("type", &mobile_os))
+  if (!mobile->GetString("type", &mobile_os))
     NOTREACHED();
   data.mobile_os = (mobile_os.compare(kTypeAndroid) == 0) ?
       ChromeToMobileService::ANDROID : ChromeToMobileService::IOS;
-  if (!mobile.GetString("id", &data.mobile_id))
+  if (!mobile->GetString("id", &data.mobile_id))
     NOTREACHED();
   content::WebContents* web_contents = chrome::GetActiveWebContents(browser);
   data.url = web_contents->GetURL();
   data.title = web_contents->GetTitle();
   data.snapshot = snapshot;
   data.snapshot_id = base::GenerateGUID();
   data.type = !snapshot.empty() ? DELAYED_SNAPSHOT : URL;
 
   net::URLFetcher* submit_url = CreateRequest(data);
   request_observer_map_[submit_url] = observer;
@@ skipping 34 matching lines @@
 }
 
 void ChromeToMobileService::LearnMore(Browser* browser) const {
   LogMetric(LEARN_MORE_CLICKED);
   chrome::NavigateParams params(browser,
       GURL(chrome::kChromeToMobileLearnMoreURL), content::PAGE_TRANSITION_LINK);
   params.disposition = NEW_FOREGROUND_TAB;
   chrome::Navigate(&params);
 }
 
-void ChromeToMobileService::OnURLFetchComplete(
-    const net::URLFetcher* source) {
-  if (source == account_info_request_.get())
-    HandleAccountInfoResponse();
-  else if (source == search_request_.get())
+void ChromeToMobileService::OnURLFetchComplete(const net::URLFetcher* source) {
+  if (source == search_request_.get())
     HandleSearchResponse();
   else
     HandleSubmitResponse(source);
 }
 
 void ChromeToMobileService::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(type, chrome::NOTIFICATION_TOKEN_AVAILABLE);
   TokenService::TokenAvailableDetails* token_details =
       content::Details<TokenService::TokenAvailableDetails>(details).ptr();
+  // Invalidate the cloud print access token on Gaia login token updates.
   if (token_details->service() == GaiaConstants::kGaiaOAuth2LoginRefreshToken)
-    RequestAccessToken();
+    access_token_.clear();
 }
 
 void ChromeToMobileService::OnGetTokenSuccess(
     const std::string& access_token,
     const base::Time& expiration_time) {
   DCHECK(!access_token.empty());
   access_token_fetcher_.reset();
   auth_retry_timer_.Stop();
   access_token_ = access_token;
-  RequestAccountInfo();
+
+  while (!task_queue_.empty()) {
+    // Post all tasks that were queued and waiting on a valid access token.
+    if (!content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
+                                          task_queue_.front())) {
+      NOTREACHED();
+    }
+    task_queue_.pop();
+  }
 }
 
 void ChromeToMobileService::OnGetTokenFailure(
     const GoogleServiceAuthError& error) {
   access_token_fetcher_.reset();
   auth_retry_timer_.Stop();
+
+  // TODO(msw): UMA Logging access token success/failure...
+  // TODO(msw): Special handling if |task_queue| is waiting?
   auth_retry_timer_.Start(
       FROM_HERE, base::TimeDelta::FromHours(kAuthRetryDelayHours),
       this, &ChromeToMobileService::RequestAccessToken);
 }
 
+void ChromeToMobileService::OnNotificationsEnabled() {
+  sync_invalidation_enabled_ = true;
+  UpdateCommandState();
+}
+
+void ChromeToMobileService::OnNotificationsDisabled(
+    syncer::NotificationsDisabledReason reason) {
+  sync_invalidation_enabled_ = false;
+  UpdateCommandState();
+}
+
+void ChromeToMobileService::OnIncomingNotification(
+    const syncer::ObjectIdPayloadMap& id_payloads,
+    syncer::IncomingNotificationSource source) {
+  DCHECK_EQ(id_payloads.size(), 1U);
+  DCHECK_EQ(id_payloads.count(invalidation::ObjectId(
+      ipc::invalidation::ObjectSource::CHROME_COMPONENTS,
+      kSyncInvalidationObjectIdChromeToMobileDeviceList)), 1U);
+  RequestDeviceSearch();
+}
+
 void ChromeToMobileService::UpdateCommandState() const {
   // Ensure the feature is not disabled by commandline options.
   DCHECK(IsChromeToMobileEnabled());
   const bool has_mobiles = HasMobiles();
   for (BrowserList::const_iterator i = BrowserList::begin();
        i != BrowserList::end(); ++i) {
     Browser* browser = *i;
     if (browser->profile() == profile_)
       browser->command_controller()->SendToMobileStateChanged(has_mobiles);
   }
@@ skipping 73 matching lines @@
     return;
   }
   cloud_print::AddMultipartValueForUpload("content", file, bound,
                                           "text/mhtml", &post);
 
   post.append("--" + bound + "--\r\n");
   request->SetUploadData("multipart/form-data; boundary=" + bound, post);
   request->Start();
 }
 
+void ChromeToMobileService::RegisterForDeviceListInvalidations() {
+  ProfileSyncService* profile_sync_service =
+      ProfileSyncServiceFactory::GetForProfile(profile_);
+  profile_sync_service->RegisterInvalidationHandler(this);

[akalin, 2012/08/17 22:09:33]

seems iffy to have this here instead of in the constructor directly.  This
function is only called once, but if it's called from somewhere else in the
future, it'll fail because it'll try to register an invalidation handler twice.

[msw, 2012/08/18 00:09:56]

Done.

+  syncer::ObjectIdSet ids;
+  ids.insert(invalidation::ObjectId(
+      ipc::invalidation::ObjectSource::CHROME_COMPONENTS,
+      kSyncInvalidationObjectIdChromeToMobileDeviceList));
+  profile_sync_service->UpdateRegisteredInvalidationIds(this, ids);
+}
+
 void ChromeToMobileService::RequestAccessToken() {
+  // Register to observe Gaia login refresh token updates.
+  TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
+  if (registrar_.IsEmpty())
+    registrar_.Add(this, chrome::NOTIFICATION_TOKEN_AVAILABLE,
+                   content::Source<TokenService>(token_service));
+
   // Deny concurrent requests and bail without a valid Gaia login refresh token.
-  TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
   if (access_token_fetcher_.get() || !token_service->HasOAuthLoginToken())
     return;
 
   auth_retry_timer_.Stop();
   access_token_fetcher_.reset(
       new OAuth2AccessTokenFetcher(this, profile_->GetRequestContext()));
   GaiaUrls* gaia_urls = GaiaUrls::GetInstance();
   access_token_fetcher_->Start(gaia_urls->oauth2_chrome_client_id(),
                                gaia_urls->oauth2_chrome_client_secret(),
                                token_service->GetOAuth2LoginRefreshToken(),
                                std::vector<std::string>(1, kCloudPrintAuth));
 }
 
-void ChromeToMobileService::RequestAccountInfo() {
-  // Deny concurrent requests.
-  if (account_info_request_.get())
-    return;
-
-  std::string url_string = StringPrintf(kAccountInfoURL,
-      base::GenerateGUID().c_str(), kChromeToMobileRequestor);
-  GURL url(url_string);
-
-  // Account information is read from the profile's cookie. If cookies are
-  // blocked, access cloud print directly to list any potential devices.
-  scoped_refptr<CookieSettings> cookie_settings =
-      CookieSettings::Factory::GetForProfile(profile_);
-  if (cookie_settings && !cookie_settings->IsReadingCookieAllowed(url, url)) {
-    cloud_print_accessible_ = true;
-    RequestMobileListUpdate();
+void ChromeToMobileService::RequestDeviceSearch() {
+  DCHECK(sync_invalidation_enabled_);
+  if (access_token_.empty()) {
+    // Enqueue this task to perform after obtaining an access token.
+    task_queue_.push(base::Bind(&ChromeToMobileService::RequestDeviceSearch,
+                                weak_ptr_factory_.GetWeakPtr()));
+    RequestAccessToken();
     return;
   }
 
-  account_info_request_.reset(
-      net::URLFetcher::Create(url, net::URLFetcher::GET, this));
-  account_info_request_->SetRequestContext(profile_->GetRequestContext());
-  account_info_request_->SetMaxRetries(kMaxRetries);
-  // This request sends the user's cookie to check the cloud print service flag.
-  account_info_request_->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES);
-  account_info_request_->Start();
-}
-
-void ChromeToMobileService::RequestDeviceSearch() {
-  // Deny requests if cloud print is inaccessible, and deny concurrent requests.
-  if (!cloud_print_accessible_ || search_request_.get())
-    return;
-
-  PrefService* prefs = profile_->GetPrefs();
-  base::TimeTicks previous_search_time = base::TimeTicks::FromInternalValue(
-      prefs->GetInt64(prefs::kChromeToMobileTimestamp));
-
-  // Deny requests before the delay period has passed since the last request.
-  base::TimeDelta elapsed_time = base::TimeTicks::Now() - previous_search_time;
-  if (!previous_search_time.is_null() &&
-      elapsed_time.InHours() < kSearchRequestDelayHours)
+  // Deny concurrent requests.
+  if (search_request_.get())
     return;
 
   LogMetric(DEVICES_REQUESTED);
 
   const GURL service_url(cloud_print_url_->GetCloudPrintServiceURL());
   search_request_.reset(net::URLFetcher::Create(GetSearchURL(service_url),
                                                 net::URLFetcher::GET, this));
   InitRequest(search_request_.get());
   search_request_->Start();
 }
 
-void ChromeToMobileService::HandleAccountInfoResponse() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-
-  std::string data;
-  account_info_request_->GetResponseAsString(&data);
-  account_info_request_.reset();
-
-  ListValue* services = NULL;
-  DictionaryValue* dictionary = NULL;
-  scoped_ptr<Value> json(base::JSONReader::Read(data));
-  StringValue cloud_print_service(kCloudPrintSerivceValue);
-  if (json.get() && json->GetAsDictionary(&dictionary) && dictionary &&
-      dictionary->GetList(kAccountServicesKey, &services) && services &&
-      services->Find(cloud_print_service) != services->end()) {
-    cloud_print_accessible_ = true;
-    RequestMobileListUpdate();
-  }
-}
-
 void ChromeToMobileService::HandleSearchResponse() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   std::string data;
   search_request_->GetResponseAsString(&data);
   search_request_.reset();
 
+  // TODO(msw): Acknowledge the sync invalidation when API exists.
+  // TODO(msw): Detect, log, potentially retry on failure / bad responses.
+  // TODO(msw): Handle removing all devices or cloud print account altogether.
+
   ListValue* list = NULL;
   DictionaryValue* dictionary = NULL;
   scoped_ptr<Value> json(base::JSONReader::Read(data));
   if (json.get() && json->GetAsDictionary(&dictionary) && dictionary &&
       dictionary->GetList(cloud_print::kPrinterListValue, &list)) {
     ListValue mobiles;
     std::string type, name, id;
     DictionaryValue* printer = NULL;
     DictionaryValue* mobile = NULL;
     for (size_t index = 0; index < list->GetSize(); ++index) {
       if (list->GetDictionary(index, &printer) &&
           printer->GetString("type", &type) &&
           (type.compare(kTypeAndroid) == 0 || type.compare(kTypeIOS) == 0)) {
         // Copy just the requisite values from the full |printer| definition.
         if (printer->GetString("displayName", &name) &&
             printer->GetString("id", &id)) {
           mobile = new DictionaryValue();
           mobile->SetString("type", type);
           mobile->SetString("name", name);
           mobile->SetString("id", id);
           mobiles.Append(mobile);
         } else {
           NOTREACHED();
         }
       }
     }
 
-    // Update the mobile list and timestamp in prefs.
-    PrefService* prefs = profile_->GetPrefs();
-    prefs->Set(prefs::kChromeToMobileDeviceList, mobiles);
-    prefs->SetInt64(prefs::kChromeToMobileTimestamp,
-                    base::TimeTicks::Now().ToInternalValue());
+    // Update the cached mobile device list in profile prefs.
+    profile_->GetPrefs()->Set(prefs::kChromeToMobileDeviceList, mobiles);
 
     if (HasMobiles())
       LogMetric(DEVICES_AVAILABLE);
     UpdateCommandState();
   }
 }
 
 void ChromeToMobileService::HandleSubmitResponse(
     const net::URLFetcher* source) {
   // Get the observer for this response; bail if there is none or it is NULL.
@@ skipping 24 matching lines @@
 
       // Ensure a second response is not sent after reporting failure below.
       request_observer_map_.erase(other);
       break;
     }
   }
 
   LogMetric(success ? SEND_SUCCESS : SEND_ERROR);
   observer->OnSendComplete(success);
 }