Dispatch geolocation IPCs on the UI thread. Aside from simplifying the code to avoid a lot of threa…

components/autofill/content/browser/risk/fingerprint.cc

 // Copyright 2013 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.
 //
 // Generating a fingerprint consists of two major steps:
 //   (1) Gather all the necessary data.
 //   (2) Write it into a protocol buffer.
 //
 // Step (2) is as simple as it sounds -- it's really just a matter of copying
 // data.  Step (1) requires waiting on several asynchronous callbacks, which are
@@ skipping 161 matching lines @@
   graphics->set_driver_version(gpu_info.driver_version);
   graphics->set_driver_date(gpu_info.driver_date);
 
   Fingerprint::MachineCharacteristics::Graphics::PerformanceStatistics*
       gpu_performance = graphics->mutable_performance_statistics();
   gpu_performance->set_graphics_score(gpu_info.performance_stats.graphics);
   gpu_performance->set_gaming_score(gpu_info.performance_stats.gaming);
   gpu_performance->set_overall_score(gpu_info.performance_stats.overall);
 }
 
-// Waits for geoposition data to be loaded.  Lives on the IO thread.
-class GeopositionLoader {
- public:
-  // |callback_| will be called on the UI thread with the loaded geoposition,
-  // once it is available.
-  GeopositionLoader(
-      const base::TimeDelta& timeout,
-      const base::Callback<void(const content::Geoposition&)>& callback);
-  ~GeopositionLoader() {}
-
- private:
-  // Methods to communicate with the GeolocationProvider.
-  void OnGotGeoposition(const content::Geoposition& geoposition);
-
-  // The callback that will be called once the geoposition is available.
-  // Will be called on the UI thread.
-  const base::Callback<void(const content::Geoposition&)> callback_;
-
-  // The callback used as an "observer" of the GeolocationProvider.
-  content::GeolocationProvider::LocationUpdateCallback geolocation_callback_;
-
-  // Timer to enforce a maximum timeout before the |callback_| is called, even
-  // if the geoposition has not been loaded.
-  base::OneShotTimer<GeopositionLoader> timeout_timer_;
-};
-
-GeopositionLoader::GeopositionLoader(
-    const base::TimeDelta& timeout,
-    const base::Callback<void(const content::Geoposition&)>& callback)
-  : callback_(callback) {
-  timeout_timer_.Start(FROM_HERE, timeout,
-                       base::Bind(&GeopositionLoader::OnGotGeoposition,
-                                  base::Unretained(this),
-                                  content::Geoposition()));
-
-  geolocation_callback_ =
-      base::Bind(&GeopositionLoader::OnGotGeoposition, base::Unretained(this));
-  content::GeolocationProvider::GetInstance()->AddLocationUpdateCallback(
-      geolocation_callback_, false);
-}
-
-void GeopositionLoader::OnGotGeoposition(
-    const content::Geoposition& geoposition) {
-  content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-                                   base::Bind(callback_, geoposition));
-
-  // Unregister as an observer, since this class instance might be destroyed
-  // after this callback.  Note: It's important to unregister *after* posting
-  // the task above.  Unregistering as an observer can have the side-effect of
-  // modifying the value of |geoposition|.
-  bool removed =
-      content::GeolocationProvider::GetInstance()->RemoveLocationUpdateCallback(
-          geolocation_callback_);
-  DCHECK(removed);
-
-  delete this;
-}
-
-// Asynchronously loads the user's current geoposition and calls |callback_| on
-// the UI thread with the loaded geoposition, once it is available. Expected to
-// be called on the IO thread.
-void LoadGeoposition(
-    const base::TimeDelta& timeout,
-    const base::Callback<void(const content::Geoposition&)>& callback) {
-  // The loader is responsible for freeing its own memory.
-  new GeopositionLoader(timeout, callback);
-}
-
 // Waits for all asynchronous data required for the fingerprint to be loaded,
 // then fills out the fingerprint.
 class FingerprintDataLoader : public content::GpuDataManagerObserver {
  public:
   FingerprintDataLoader(
       uint64 obfuscated_gaia_id,
       const gfx::Rect& window_bounds,
       const gfx::Rect& content_bounds,
       const WebScreenInfo& screen_info,
       const std::string& version,
@@ skipping 54 matching lines @@
   // if not all asynchronous data has been loaded.
   base::OneShotTimer<FingerprintDataLoader> timeout_timer_;
 
   // For invalidating asynchronous callbacks that might arrive after |this|
   // instance is destroyed.
   base::WeakPtrFactory<FingerprintDataLoader> weak_ptr_factory_;
 
   // The callback that will be called once all the data is available.
   base::Callback<void(scoped_ptr<Fingerprint>)> callback_;
 
+  // The callback used as an "observer" of the GeolocationProvider.
+  scoped_ptr<content::GeolocationProvider::Subscription>
+      geolocation_subscription_;
+
   DISALLOW_COPY_AND_ASSIGN(FingerprintDataLoader);
 };
 
 FingerprintDataLoader::FingerprintDataLoader(
     uint64 obfuscated_gaia_id,
     const gfx::Rect& window_bounds,
     const gfx::Rect& content_bounds,
     const WebScreenInfo& screen_info,
     const std::string& version,
     const std::string& charset,
@@ skipping 39 matching lines @@
 #else
   waiting_on_plugins_ = false;
 #endif
 
   // Load font data.
   content::GetFontListAsync(
       base::Bind(&FingerprintDataLoader::OnGotFonts,
                  weak_ptr_factory_.GetWeakPtr()));
 
   // Load geolocation data.
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&LoadGeoposition,
-                 timeout,
-                 base::Bind(&FingerprintDataLoader::OnGotGeoposition,
-                            weak_ptr_factory_.GetWeakPtr())));
+  geolocation_subscription_ = content::GeolocationProvider::GetInstance()->
+      AddLocationUpdateCallback(
+          base::Bind(&FingerprintDataLoader::OnGotGeoposition,
+                      weak_ptr_factory_.GetWeakPtr()),
+          false);
 }
 
 void FingerprintDataLoader::OnGpuInfoUpdate() {
   if (!gpu_data_manager_->IsCompleteGpuInfoAvailable())
     return;
 
   gpu_observer_.Remove(gpu_data_manager_);
   MaybeFillFingerprint();
 }
 
@@ skipping 11 matching lines @@
   MaybeFillFingerprint();
 }
 
 void FingerprintDataLoader::OnGotGeoposition(
     const content::Geoposition& geoposition) {
   DCHECK(!geoposition_.Validate());
 
   geoposition_ = geoposition;
   DCHECK(geoposition_.Validate() ||
          geoposition_.error_code != content::Geoposition::ERROR_CODE_NONE);
+  geolocation_subscription_.reset();
 
   MaybeFillFingerprint();
 }
 
 void FingerprintDataLoader::MaybeFillFingerprint() {
   // If all of the data has been loaded, or if the |timeout_timer_| has expired,
   // fill the fingerprint and clean up.
   if (!timeout_timer_.IsRunning() ||
       ((!gpu_data_manager_->GpuAccessAllowed(NULL) ||
         gpu_data_manager_->IsCompleteGpuInfoAvailable()) &&
@@ skipping 117 matching lines @@
     host_view->GetRenderWidgetHost()->GetWebScreenInfo(&screen_info);
 
   internal::GetFingerprintInternal(
       obfuscated_gaia_id, window_bounds, content_bounds, screen_info, version,
       charset, accept_languages, install_time, app_locale, user_agent,
       base::TimeDelta::FromSeconds(kTimeoutSeconds), callback);
 }
 
 }  // namespace risk
 }  // namespace autofill