[Autofill] Add geolocation data to Risk fingerprint.

components/autofill/browser/risk/fingerprint.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 "components/autofill/browser/risk/fingerprint.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/cpu.h"
 #include "base/logging.h"
 #include "base/strings/string_split.h"
 #include "base/sys_info.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "components/autofill/browser/risk/proto/fingerprint.pb.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/font_list_async.h"
+#include "content/public/browser/geolocation_provider.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/browser/gpu_data_manager_observer.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/common/content_client.h"
+#include "content/public/common/geoposition.h"
 #include "content/public/common/gpu_info.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRect.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebScreenInfo.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/screen.h"
 #include "webkit/plugins/webplugininfo.h"
 
 using WebKit::WebScreenInfo;
 
 namespace autofill {
@@ skipping 157 matching lines @@
 
  private:
   virtual ~FingerprintDataLoader();
 
   // content::GpuDataManagerObserver:
   virtual void OnGpuInfoUpdate() OVERRIDE;
 
   // Callbacks for asynchronously loaded data.
   void OnGotFonts(scoped_ptr<base::ListValue> fonts);
   void OnGotPlugins(const std::vector<webkit::WebPluginInfo>& plugins);
+  void OnGotGeoposition(const content::Geoposition& geoposition);
+
+  // Methods that run on the IO thread to communicate with the
+  // GeolocationProvider.
+  void LoadGeoposition();
+  void OnGotGeopositionOnIOThread(const content::Geoposition& geoposition);
 
   // If all of the asynchronous data has been loaded, calls |callback_| with
   // the fingerprint data.
   void MaybeFillFingerprint();
 
   // Calls |callback_| with the fingerprint data.
   void FillFingerprint();
 
   // The GPU data provider.
   content::GpuDataManager* const gpu_data_manager_;
 
+  // The callback used as an "observer" of the GeolocationProvider.  Accessed
+  // only on the IO thread.
+  content::GeolocationProvider::LocationUpdateCallback geolocation_callback_;
+
   // Data that will be passed on to the next loading phase.
   const int64 gaia_id_;
   const gfx::Rect window_bounds_;
   const gfx::Rect content_bounds_;
   const WebScreenInfo screen_info_;
   const std::string version_;
   const std::string charset_;
   const std::string accept_languages_;
   const base::Time install_time_;
   DialogType dialog_type_;
 
   // Data that will be loaded asynchronously.
   scoped_ptr<base::ListValue> fonts_;
   std::vector<webkit::WebPluginInfo> plugins_;
   bool has_loaded_plugins_;
+  content::Geoposition geoposition_;
 
   // The current application locale.
   std::string app_locale_;
 
   // The callback that will be called once all the data is available.
   base::Callback<void(scoped_ptr<Fingerprint>)> callback_;
 
   DISALLOW_COPY_AND_ASSIGN(FingerprintDataLoader);
 };
 
@@ skipping 29 matching lines @@
     gpu_data_manager_->RequestCompleteGpuInfoIfNeeded();
   }
 
   // Load plugin data.
   content::PluginService::GetInstance()->GetPlugins(
       base::Bind(&FingerprintDataLoader::OnGotPlugins, base::Unretained(this)));
 
   // Load font data.
   content::GetFontListAsync(
       base::Bind(&FingerprintDataLoader::OnGotFonts, base::Unretained(this)));
+
+  // Load geolocation data.
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&FingerprintDataLoader::LoadGeoposition,
+                 base::Unretained(this)));
 }
 
 FingerprintDataLoader::~FingerprintDataLoader() {
 }
 
 void FingerprintDataLoader::OnGpuInfoUpdate() {
   if (!gpu_data_manager_->IsCompleteGpuInfoAvailable())
     return;
 
   gpu_data_manager_->RemoveObserver(this);
   MaybeFillFingerprint();
 }
 
 void FingerprintDataLoader::OnGotFonts(scoped_ptr<base::ListValue> fonts) {
   DCHECK(!fonts_);
   fonts_.reset(fonts.release());
   MaybeFillFingerprint();
 }
 
 void FingerprintDataLoader::OnGotPlugins(
     const std::vector<webkit::WebPluginInfo>& plugins) {
   DCHECK(!has_loaded_plugins_);
   has_loaded_plugins_ = true;
   plugins_ = plugins;
   MaybeFillFingerprint();
 }
 
+void FingerprintDataLoader::OnGotGeoposition(
+    const content::Geoposition& geoposition) {
+  DCHECK(!geoposition_.Validate());
+
+  geoposition_ = geoposition;
+  DCHECK(geoposition_.Validate() ||
+         geoposition_.error_code != content::Geoposition::ERROR_CODE_NONE);
+
+  MaybeFillFingerprint();
+}
+
+void FingerprintDataLoader::LoadGeoposition() {
+  geolocation_callback_ =
+      base::Bind(&FingerprintDataLoader::OnGotGeopositionOnIOThread,
+                 base::Unretained(this));
+  content::GeolocationProvider::GetInstance()->AddLocationUpdateCallback(
+      geolocation_callback_, false);
+}
+
+void FingerprintDataLoader::OnGotGeopositionOnIOThread(
+    const content::Geoposition& geoposition) {
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(&FingerprintDataLoader::OnGotGeoposition,
+                 base::Unretained(this), 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);
+}
+
 void FingerprintDataLoader::MaybeFillFingerprint() {
   // If all of the data has been loaded, fill the fingerprint and clean up.
   if (gpu_data_manager_->IsCompleteGpuInfoAvailable() &&
       fonts_ &&
-      has_loaded_plugins_) {
+      has_loaded_plugins_ &&
+      (geoposition_.Validate() ||
+       geoposition_.error_code != content::Geoposition::ERROR_CODE_NONE)) {
     FillFingerprint();
     delete this;
   }
 }
 
 void FingerprintDataLoader::FillFingerprint() {
   scoped_ptr<Fingerprint> fingerprint(new Fingerprint);
   Fingerprint_MachineCharacteristics* machine =
       fingerprint->mutable_machine_characteristics();
 
@@ skipping 25 matching lines @@
   inner_window_size->set_width(content_bounds_.width());
   inner_window_size->set_height(content_bounds_.height());
   Fingerprint_Dimension* outer_window_size =
       transient_state->mutable_outer_window_size();
   outer_window_size->set_width(window_bounds_.width());
   outer_window_size->set_height(window_bounds_.height());
 
   // TODO(isherman): Record network performance data, which is theoretically
   // available to JS.
 
-  // TODO(isherman): Record user behavior data.
+  // TODO(isherman): Record more user behavior data.
+  if (geoposition_.error_code == content::Geoposition::ERROR_CODE_NONE) {
+    Fingerprint_UserCharacteristics_Location* location =
+        fingerprint->mutable_user_characteristics()->mutable_location();
+    location->set_altitude(geoposition_.altitude);
+    location->set_latitude(geoposition_.latitude);
+    location->set_longitude(geoposition_.longitude);
+    location->set_accuracy(geoposition_.accuracy);
+    location->set_time_in_ms(
+        (geoposition_.timestamp - base::Time::UnixEpoch()).InMilliseconds());
+  }
 
   Fingerprint_Metadata* metadata = fingerprint->mutable_metadata();
   metadata->set_timestamp_ms(
       (base::Time::Now() - base::Time::UnixEpoch()).InMilliseconds());
   metadata->set_gaia_id(gaia_id_);
   metadata->set_fingerprinter_version(kFingerprinterVersion);
 
   callback_.Run(fingerprint.Pass());
 }
 
@@ skipping 42 matching lines @@
   // This class is responsible for freeing its own memory.
   new FingerprintDataLoader(gaia_id, window_bounds, content_bounds, screen_info,
                             version, charset, accept_languages, install_time,
                             dialog_type, app_locale, callback);
 }
 
 }  // namespace internal
 
 }  // namespace risk
 }  // namespace autofill