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"
 
 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.
+// 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 86 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),
+      sync_invalidation_enabled_(false),
       cloud_print_url_(new CloudPrintURL(profile)),
-      cloud_print_accessible_(false) {
-  // Skip initialization if constructed without a profile.
+      request_search_when_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())
-      RefreshAccessToken();
+    ProfileSyncService* profile_sync_service =
+        ProfileSyncServiceFactory::GetForProfile(profile_);
+    profile_sync_service->RegisterInvalidationHandler(this);
+    syncer::ObjectIdSet ids;
+    ids.insert(invalidation::ObjectId(
+        ipc::invalidation::ObjectSource::CHROME_COMPONENTS,
+        kSyncInvalidationObjectIdChromeToMobileDeviceList));
+    profile_sync_service->UpdateRegisteredInvalidationIds(this, ids);

[akalin, 2012/08/13 22:23:58]

what's the code path where chrome to phone is disabled?  is there one, or is it
completely tied to sync?  if it's the latter, then you may have to listen to
sync notifications and unregister if you detect that sync was disabled

[msw, 2012/08/16 02:41:51]

It's tied to sync invalidation (presuming commandline flags allow
ChromeToMobileService instantiation). Do you mean to unregister the handler
and/or ids if OnNotificationsDisabled is called? That seems odd.

+    // TODO(msw): Use IsSyncEnabled? Is OnNotificationsEnabled called now?

[akalin, 2012/08/13 22:23:58]

don't use IsSyncEnabled.  I plan to have OnNotifications{Enabled,Disabled}
called when you register an invalidation handler (
https://code.google.com/p/chromium/issues/detail?id=142475 )

Maybe for now assume that it's enabled until told otherwise and add a TODO to
switch to disabled?  Or just wait for my fix to land

[msw, 2012/08/16 02:41:51]

Done. OnNotificationsEnabled seems to be called all the time already.

+    sync_invalidation_enabled_ = profile_sync_service->IsSyncEnabled();
   }
+  UpdateCommandState();
 }
 
 ChromeToMobileService::~ChromeToMobileService() {
   while (!snapshots_.empty())
     DeleteSnapshot(*snapshots_.begin());
+  if (profile_)

[akalin, 2012/08/13 22:23:58]

i think you can omit braces only if the 'then' statement fits on one line

[msw, 2012/08/16 02:41:51]

Done.

+    ProfileSyncServiceFactory::GetForProfile(profile_)->
+        UnregisterInvalidationHandler(this);
 }
 
-bool ChromeToMobileService::HasMobiles() {
-  return !GetMobiles()->empty();
+bool ChromeToMobileService::HasMobiles() const {
+  return sync_invalidation_enabled_ && !GetMobiles()->empty();
 }
 
 const base::ListValue* ChromeToMobileService::GetMobiles() const {
+  if (!sync_invalidation_enabled_)
+    return NULL;
+
   return profile_->GetPrefs()->GetList(prefs::kChromeToMobileDeviceList);
 }
 
 void ChromeToMobileService::RequestMobileListUpdate() {
-  if (access_token_.empty())
+  if (!sync_invalidation_enabled_)
+    return;
+
+  if (access_token_.empty()) {
+    request_search_when_accessible_ = true;
     RefreshAccessToken();
-  else if (cloud_print_accessible_)
+  } else {
     RequestSearch();
+  }
 }
 
 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.
@@ skipping 56 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();
+  // Update the cloud print access token on Gaia login refresh token updates.
   if (token_details->service() == GaiaConstants::kGaiaOAuth2LoginRefreshToken)
     RefreshAccessToken();
 }
 
 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();
+
+  if (request_search_when_accessible_) {
+    request_search_when_accessible_ = false;
+    RequestSearch();
+  }
 }
 
 void ChromeToMobileService::OnGetTokenFailure(
     const GoogleServiceAuthError& error) {
   access_token_fetcher_.reset();
   auth_retry_timer_.Stop();
   auth_retry_timer_.Start(
       FROM_HERE, base::TimeDelta::FromHours(kAuthRetryDelayHours),
       this, &ChromeToMobileService::RefreshAccessToken);
 }
 
+void ChromeToMobileService::OnNotificationsEnabled() {
+  // Only enable Chrome To Mobile if Sync Invalidation Notification are enabled.
+  // Otherwise, the device list may be out of date and result in send failures.
+  sync_invalidation_enabled_ = true;
+  UpdateCommandState();
+}
+
+void ChromeToMobileService::OnNotificationsDisabled(
+    syncer::NotificationsDisabledReason reason) {
+  // Only enable Chrome To Mobile if Sync Invalidation Notification are enabled.
+  // Otherwise, the device list may be out of date and result in send failures.
+  sync_invalidation_enabled_ = false;
+  UpdateCommandState();
+}
+
+void ChromeToMobileService::OnIncomingNotification(
+    const syncer::ObjectIdPayloadMap& id_payloads,
+    syncer::IncomingNotificationSource source) {
+  DCHECK(sync_invalidation_enabled_);

[akalin, 2012/08/13 22:23:58]

i don't know if this should be a DCHECK.  The API doesn't guarantee that
notifications come only when they're enabled (due to caching, etc. you may get
some notifications before it goes to a fully enabled state, etc.)

[msw, 2012/08/16 02:41:51]

Odd; then I'll just use it to gate the feature w/[Has|Get]Mobiles().

+  DCHECK_EQ(id_payloads.size(), 1U);
+  DCHECK_EQ(id_payloads.count(invalidation::ObjectId(
+      ipc::invalidation::ObjectSource::CHROME_COMPONENTS,
+      kSyncInvalidationObjectIdChromeToMobileDeviceList)), 1U);
+  RequestMobileListUpdate();
+}
+
+// TODO(msw): Audit location bar code that checks enabled/disabled...
+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);
+  }
+}
+
 void ChromeToMobileService::SnapshotFileCreated(
     base::WeakPtr<Observer> observer,
     SessionID::id_type browser_id,
     const FilePath& path,
     bool success) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   // Track the set of temporary files to be deleted later.
   snapshots_.insert(path);
 
   Browser* browser = browser::FindBrowserWithID(browser_id);
@@ skipping 61 matching lines @@
   }
   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::RefreshAccessToken() {
-  if (access_token_fetcher_.get())
-    return;
+  // 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));
 
-  std::string token = TokenServiceFactory::GetForProfile(profile_)->
-                          GetOAuth2LoginRefreshToken();
-  if (token.empty())
+  // Deny concurrent requests and bail without a valid Gaia login refresh token.
+  if (access_token_fetcher_.get() || !token_service->HasOAuthLoginToken())
     return;
 
   auth_retry_timer_.Stop();
   access_token_fetcher_.reset(
       new OAuth2AccessTokenFetcher(this, profile_->GetRequestContext()));
-  std::vector<std::string> scopes(1, kCloudPrintAuth);
   GaiaUrls* gaia_urls = GaiaUrls::GetInstance();
   access_token_fetcher_->Start(gaia_urls->oauth2_chrome_client_id(),
-      gaia_urls->oauth2_chrome_client_secret(), token, scopes);
-}
-
-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();
-    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();
+                               gaia_urls->oauth2_chrome_client_secret(),
+                               token_service->GetOAuth2LoginRefreshToken(),
+                               std::vector<std::string>(1, kCloudPrintAuth));
 }
 
 void ChromeToMobileService::RequestSearch() {
+  DCHECK(sync_invalidation_enabled_);
   DCHECK(!access_token_.empty());
 
-  // 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): Ackowledge 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("name", &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);
 
-    const bool has_mobiles = HasMobiles();
-    if (has_mobiles)
+    if (HasMobiles())
       LogMetric(DEVICES_AVAILABLE);
-
-    for (BrowserList::const_iterator i = BrowserList::begin();
-         i != BrowserList::end(); ++i) {
-      Browser* browser = *i;
-      if (browser->profile() == profile_)
-        browser->command_controller()->SendToMobileStateChanged(has_mobiles);
-    }
+    UpdateCommandState();
   }
 }
 
 void ChromeToMobileService::HandleSubmitResponse(
     const net::URLFetcher* source) {
   // Get the observer for this response; bail if there is none or it is NULL.
   RequestObserverMap::iterator i = request_observer_map_.find(source);
   if (i == request_observer_map_.end())
     return;
   base::WeakPtr<Observer> observer = i->second;
@@ skipping 20 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);
 }