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 = false;
 
 // 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;
 
+// TODO(msw): Push back for enum values, instead of these string contstants?
+// The invalidation object ID for the User space, Chrome to Mobile, Mobile LiST.
+// ("U" == "User", "CM" == "Chrome to Mobile", "MLST" == "Mobile LiST").
+const char kMobileListObjectId[] = "UCMMLST";

[akalin, 2012/08/08 23:06:27]

i think object id names have to be strings

[msw, 2012/08/10 22:05:05]

I've voiced my dissent, but will go along :)
"It won't be my problem down the road..." - msw

[akalin, 2012/08/10 23:03:22]

I understand you don't like strings, but I don't know of any alternatives.  The
object ID names are part of the ticl protocol, right?

[nyquist, 2012/08/10 23:46:39]

The object ID name must match whatever the source sends, in this case Cloud
Print. There is server-side validation for this, and it is alphanumeric-based.

We should probably have some way of making sure we don't reuse object ID name
space, such as here, "CM" which is the chrome component project ID.

+
 // 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";
@@ skipping 99 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);
+  // TODO(msw): Okay to change a pref from Int64 to string?
+  // TODO(msw): Consider renaming timestamp to version? Which is it?
+  prefs->RegisterStringPref(prefs::kChromeToMobileTimestamp, "",

[akalin, 2012/08/08 23:06:27]

just to be clear, this is different from the invalidation timestamp/version?

[msw, 2012/08/10 22:05:05]

Removed. I was changing it to match the last received invalidation
timestamp/version to ensure that we'd only update the device list when truly
needed, but Tommy explained offline that this shouldn't be necessary.

As I understand, OnIncomingNotification should correctly trigger updates from
cloud print without Chrome To Mobile needing to store or check a
timestamp/version. Please let me know if I'm wrong!

+                            PrefService::UNSYNCABLE_PREF);
 }
 
 ChromeToMobileService::ChromeToMobileService(Profile* profile)
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
       profile_(profile),
+      mobile_list_id_(ipc::invalidation::ObjectSource::CHROME_COMPONENTS,
+                      kMobileListObjectId),
+      sync_invalidation_enabled_(false),
       cloud_print_url_(new CloudPrintURL(profile)),
       cloud_print_accessible_(false) {
   // Skip initialization if constructed without a profile.
   if (profile_) {

[dcheng, 2012/08/08 23:11:10]

Why do you need to check profile_ here and not other places (line 244). Maybe
just DCHECK(profile) and remove the checks. Same comment on other places that
use profile_.

[msw, 2012/08/10 22:05:05]

It's for the GMock unit tests, which provide a NULL profile to this ctor and
mock out other profile-dependent locations. This isn't ideal, I clarified the
comment as a TODO pointing to http://crbug.com/122183 (for now, will follow up).

     // Get an access token as soon as the Gaia login refresh token is available.
-    TokenService* service = TokenServiceFactory::GetForProfile(profile_);
+    TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
     registrar_.Add(this, chrome::NOTIFICATION_TOKEN_AVAILABLE,
-                   content::Source<TokenService>(service));
-    if (service->HasOAuthLoginToken())
+                   content::Source<TokenService>(token_service));
+    if (token_service->HasOAuthLoginToken())
       RefreshAccessToken();
+
+    ProfileSyncService* profile_sync_service =
+        ProfileSyncServiceFactory::GetForProfile(profile_);
+    // TODO(msw): Update with https://chromiumcodereview.appspot.com/10824161/
+    //profile_sync_service->AddHandler(this);
+    sync_objects_.insert(mobile_list_id_);
+    profile_sync_service->UpdateRegisteredInvalidationIds(this, sync_objects_);
+    // TODO(msw): Check if sync_invalidation_enabled_ directly here?

[akalin, 2012/08/08 23:06:27]

Hmm, I guess you need some way to check if notifications are enabled.

[msw, 2012/08/10 22:05:05]

How about profile_sync_service->IsSyncEnabled()? Not sure if you meant I should
use ShouldPushChanges() for this in http://crbug.com/137086 ?

+    // TODO(msw): Or are we always pinged via OnNotificationsEnabled?
   }
 }
 
 ChromeToMobileService::~ChromeToMobileService() {
   while (!snapshots_.empty())
     DeleteSnapshot(*snapshots_.begin());
+  if (profile_) {
+    // TODO(msw): Update with https://chromiumcodereview.appspot.com/10824161/
+    //ProfileSyncService* profile_sync_service =
+    //    ProfileSyncServiceFactory::GetForProfile(profile_);
+    //profile_sync_service->RemoveHandler(this);
+  }
 }
 
 bool ChromeToMobileService::HasMobiles() {
-  return !GetMobiles()->empty();
+  const base::ListValue* mobiles = GetMobiles();
+  return mobiles && !mobiles->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())
     RefreshAccessToken();
-  else if (cloud_print_accessible_)
+  else if (sync_invalidation_enabled_ && cloud_print_accessible_)
     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());
@@ skipping 97 matching lines @@
 
 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.
+  // TODO(msw): Load the cached mobile list now (instead of sync_invalidation_enabled_)?
+  sync_invalidation_enabled_ = true;
+}
+
+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.
+  // TODO(msw): Clear the cached mobile list now (instead of sync_invalidation_enabled_)?
+  sync_invalidation_enabled_ = false;
+}
+
+void ChromeToMobileService::OnIncomingNotification(
+    const syncer::ObjectIdPayloadMap& id_payloads,
+    syncer::IncomingNotificationSource source) {
+  DCHECK(sync_invalidation_enabled_);
+  DCHECK_EQ(id_payloads.size(), 1U);
+  DCHECK_EQ(id_payloads.count(mobile_list_id_), 1U);
+  std::string new_timestamp = id_payloads.find(mobile_list_id_)->second;
+
+  PrefService* prefs = profile_->GetPrefs();
+  std::string timestamp = prefs->GetString(prefs::kChromeToMobileTimestamp);
+  // TODO(msw): Check if the timestamp is newer? Or just different?
+  if (!new_timestamp.empty() && timestamp.compare(new_timestamp) != 0) {
+    // TODO(msw): Update the cached timestamp now, or only on successful update?
+    prefs->SetString(prefs::kChromeToMobileTimestamp, new_timestamp);
+    RequestMobileListUpdate();
+  }
+}
+
 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 93 matching lines @@
   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();
+    // TODO(msw): Don't poll now... 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();
 }
 
 void ChromeToMobileService::RequestSearch() {
   DCHECK(!access_token_.empty());
+  DCHECK(sync_invalidation_enabled_);
 
   // 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)
-    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();
+    // TODO(msw): Don't poll now... RequestMobileListUpdate();
   }
 }
 
 void ChromeToMobileService::HandleSearchResponse() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   std::string data;
   search_request_->GetResponseAsString(&data);
   search_request_.reset();
 
@@ skipping 17 matching lines @@
           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 mobile list in prefs.
+    // TODO(msw): Update the timestamp now (only on successful list updates?)
+    profile_->GetPrefs()->Set(prefs::kChromeToMobileDeviceList, mobiles);
 
     const bool has_mobiles = HasMobiles();
     if (has_mobiles)
       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);
@@ skipping 31 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);
 }