Chrome To Mobile Service refactoring and polish, etc.

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"
@@ skipping 122 matching lines @@
   return search_url.ReplaceComponents(replacements);
 }
 
 // A callback to continue snapshot generation after creating the temp file.
 typedef base::Callback<void(const FilePath& path, bool success)>
     CreateSnapshotFileCallback;
 
 // Create a temp file and post the callback on the UI thread with the results.
 // Call this as a BlockingPoolTask to avoid the FILE thread.
 void CreateSnapshotFile(CreateSnapshotFileCallback callback) {
-  FilePath snapshot;
-  bool success = file_util::CreateTemporaryFile(&snapshot);
-  content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-                                   base::Bind(callback, snapshot, success));
+  FilePath file;
+  bool success = file_util::CreateTemporaryFile(&file);
+  if (!content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
+                                        base::Bind(callback, file, success))) {
+    NOTREACHED();
+  }
 }
 
 // Delete the snapshot file; DCHECK, but really ignore the result of the delete.
 // Call this as a BlockingPoolSequencedTask [after posting SubmitSnapshotFile].
 void DeleteSnapshotFile(const FilePath& snapshot) {
   bool success = file_util::Delete(snapshot, false);
   DCHECK(success);
 }
 
 }  // namespace
@@ skipping 23 matching lines @@
                           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) {
-  // Skip initialization if constructed without a profile.
+  // 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();
+      RequestAccessToken();
   }
 }
 
 ChromeToMobileService::~ChromeToMobileService() {
   while (!snapshots_.empty())
     DeleteSnapshot(*snapshots_.begin());
 }
 
-bool ChromeToMobileService::HasMobiles() {
+bool ChromeToMobileService::HasMobiles() const {
   return !GetMobiles()->empty();
 }
 
 const base::ListValue* ChromeToMobileService::GetMobiles() const {
   return profile_->GetPrefs()->GetList(prefs::kChromeToMobileDeviceList);
 }
 
 void ChromeToMobileService::RequestMobileListUpdate() {
   if (access_token_.empty())
-    RefreshAccessToken();
+    RequestAccessToken();
   else if (cloud_print_accessible_)
-    RequestSearch();
+    RequestDeviceSearch();
 }
 
 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.
-  content::BrowserThread::PostBlockingPoolTask(FROM_HERE,
-      base::Bind(&CreateSnapshotFile, callback));
+  if (!content::BrowserThread::PostBlockingPoolTask(FROM_HERE,
+          base::Bind(&CreateSnapshotFile, callback))) {
+    NOTREACHED();
+  }
 }
 
 void ChromeToMobileService::SendToMobile(const base::DictionaryValue& mobile,
                                          const FilePath& snapshot,
                                          Browser* browser,
                                          base::WeakPtr<Observer> observer) {
   LogMetric(SENDING_URL);
 
-  DCHECK(!access_token_.empty());
   JobData data;
   std::string 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))
     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;
   SendRequest(submit_url, data);
 
   if (data.type == DELAYED_SNAPSHOT) {
     LogMetric(SENDING_SNAPSHOT);
 
     data.type = SNAPSHOT;
     net::URLFetcher* submit_snapshot = CreateRequest(data);
     request_observer_map_[submit_snapshot] = observer;
-    content::BrowserThread::PostBlockingPoolSequencedTask(
-        data.snapshot.AsUTF8Unsafe(), FROM_HERE,
-        base::Bind(&ChromeToMobileService::SendRequest,
-                   weak_ptr_factory_.GetWeakPtr(), submit_snapshot, data));
+    if (!content::BrowserThread::PostBlockingPoolSequencedTask(
+            data.snapshot.AsUTF8Unsafe(), FROM_HERE,
+            base::Bind(&ChromeToMobileService::SendRequest,
+                       weak_ptr_factory_.GetWeakPtr(),
+                       submit_snapshot, data))) {
+      NOTREACHED();
+    }
   }
 }
 
 void ChromeToMobileService::DeleteSnapshot(const FilePath& snapshot) {
   DCHECK(snapshot.empty() || snapshots_.find(snapshot) != snapshots_.end());
   if (snapshots_.find(snapshot) != snapshots_.end()) {
-    if (!snapshot.empty())
-      content::BrowserThread::PostBlockingPoolSequencedTask(
-          snapshot.AsUTF8Unsafe(), FROM_HERE,
-          base::Bind(&DeleteSnapshotFile, snapshot));
+    if (!snapshot.empty()) {
+      if (!content::BrowserThread::PostBlockingPoolSequencedTask(
+              snapshot.AsUTF8Unsafe(), FROM_HERE,
+              base::Bind(&DeleteSnapshotFile, snapshot))) {
+        NOTREACHED();
+      }
+    }
     snapshots_.erase(snapshot);
   }
 }
 
 void ChromeToMobileService::LogMetric(Metric metric) const {
   UMA_HISTOGRAM_ENUMERATION("ChromeToMobile.Service", metric, NUM_METRICS);
 }
 
 void ChromeToMobileService::LearnMore(Browser* browser) const {
   LogMetric(LEARN_MORE_CLICKED);
@@ skipping 14 matching lines @@
 }
 
 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();
   if (token_details->service() == GaiaConstants::kGaiaOAuth2LoginRefreshToken)
-    RefreshAccessToken();
+    RequestAccessToken();
 }
 
 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();
 }
 
 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);
+      this, &ChromeToMobileService::RequestAccessToken);
+}
+
+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);
@@ skipping 13 matching lines @@
   const GURL service_url(cloud_print_url_->GetCloudPrintServiceURL());
   net::URLFetcher* request = net::URLFetcher::Create(
       cloud_print::GetUrlForSubmit(service_url), net::URLFetcher::POST, this);
   InitRequest(request);
   return request;
 }
 
 void ChromeToMobileService::InitRequest(net::URLFetcher* request) {
   request->SetRequestContext(profile_->GetRequestContext());
   request->SetMaxRetries(kMaxRetries);
+  DCHECK(!access_token_.empty());
   request->SetExtraRequestHeaders("Authorization: OAuth " +
       access_token_ + "\r\n" + cloud_print::kChromeCloudPrintProxyHeader);
   request->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                         net::LOAD_DO_NOT_SAVE_COOKIES);
 }
 
 void ChromeToMobileService::SendRequest(net::URLFetcher* request,
                                         const JobData& data) {
   std::string post, bound;
   cloud_print::CreateMimeBoundaryForUpload(&bound);
@@ skipping 29 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::RefreshAccessToken() {
-  if (access_token_fetcher_.get())
-    return;
-
-  std::string token = TokenServiceFactory::GetForProfile(profile_)->
-                          GetOAuth2LoginRefreshToken();
-  if (token.empty())
+void ChromeToMobileService::RequestAccessToken() {
+  // 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()));
-  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);
+                               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);
@@ skipping 10 matching lines @@
 
   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());
-
+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;
@@ skipping 43 matching lines @@
       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) &&
+        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());
 
-    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);
 }