Store ChromeToMobile device list and timestamp prefs.

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/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 "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"
 
@@ skipping 121 matching lines @@
 
   if (command_line->HasSwitch(switches::kDisableChromeToMobile))
     return false;
 
   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) {
   // Skip initialization if constructed without a profile.
   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();
   }
 }
 
 ChromeToMobileService::~ChromeToMobileService() {
   while (!snapshots_.empty())
     DeleteSnapshot(*snapshots_.begin());
 }
 
-bool ChromeToMobileService::HasDevices() {
-  return !mobiles().empty();
+bool ChromeToMobileService::HasMobiles() {
+  return !GetMobiles()->empty();
+}
+
+const base::ListValue* ChromeToMobileService::GetMobiles() const {
+  return profile_->GetPrefs()->GetList(prefs::kChromeToMobileDeviceList);
 }
 
 void ChromeToMobileService::RequestMobileListUpdate() {
   if (access_token_.empty())
     RefreshAccessToken();
   else if (cloud_print_accessible_)
     RequestSearch();
 }
 
 void ChromeToMobileService::GenerateSnapshot(Browser* browser,
@@ skipping 236 matching lines @@
   account_info_request_->Start();
 }
 
 void ChromeToMobileService::RequestSearch() {
   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() &&
+  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();
-  previous_search_time_ = base::TimeTicks::Now();
 }
 
 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;
@@ skipping 13 matching lines @@
 
   std::string data;
   search_request_->GetResponseAsString(&data);
   search_request_.reset();
 
   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)) {
-    mobiles_.Clear();
-
+    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);
+          mobiles.Append(mobile);
         } else {
           NOTREACHED();
         }
       }
     }
 
-    const bool has_devices = HasDevices();
-    if (has_devices)
+    // 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)
       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_devices);
+        browser->command_controller()->SendToMobileStateChanged(has_mobiles);
     }
   }
 }
 
 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;
@@ skipping 21 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);
 }