Load and send Wallet Risk params after user has agreed

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"
@@ skipping 161 matching lines @@
   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 all asynchronous data required for the fingerprint to be loaded;
 // then fills out the fingerprint.
 class FingerprintDataLoader : public content::GpuDataManagerObserver {
  public:
   FingerprintDataLoader(
-      int64 gaia_id,
+      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,
       const std::string& accept_languages,
       const base::Time& install_time,
       DialogType dialog_type,
       const std::string& app_locale,
       const base::Callback<void(scoped_ptr<Fingerprint>)>& callback);
@@ skipping 12 matching lines @@
   // the fingerprint data.
   void MaybeFillFingerprint();
 
   // Calls |callback_| with the fingerprint data.
   void FillFingerprint();
 
   // The GPU data provider.
   content::GpuDataManager* const gpu_data_manager_;
 
   // Data that will be passed on to the next loading phase.
-  const int64 gaia_id_;
+  const 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_;
   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_;
 
   // 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);
 };
 
 FingerprintDataLoader::FingerprintDataLoader(
-    int64 gaia_id,
+    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,
     const std::string& accept_languages,
     const base::Time& install_time,
     DialogType dialog_type,
     const std::string& app_locale,
     const base::Callback<void(scoped_ptr<Fingerprint>)>& callback)
     : gpu_data_manager_(content::GpuDataManager::GetInstance()),
-      gaia_id_(gaia_id),
+      obfuscated_gaia_id_(obfuscated_gaia_id),
       window_bounds_(window_bounds),
       content_bounds_(content_bounds),
       screen_info_(screen_info),
       version_(version),
       charset_(charset),
       accept_languages_(accept_languages),
       install_time_(install_time),
       dialog_type_(dialog_type),
       has_loaded_plugins_(false),
       callback_(callback) {
   DCHECK(!install_time_.is_null());
 
   // Load GPU data if needed.
   if (!gpu_data_manager_->IsCompleteGpuInfoAvailable()) {
     gpu_data_manager_->AddObserver(this);
     gpu_data_manager_->RequestCompleteGpuInfoIfNeeded();
   }
 
+#if defined(USE_PLUGINS)
   // Load plugin data.
   content::PluginService::GetInstance()->GetPlugins(
       base::Bind(&FingerprintDataLoader::OnGotPlugins, base::Unretained(this)));
+#endif
 
   // Load font data.
   content::GetFontListAsync(
       base::Bind(&FingerprintDataLoader::OnGotFonts, base::Unretained(this)));
 }
 
 FingerprintDataLoader::~FingerprintDataLoader() {
 }
 
 void FingerprintDataLoader::OnGpuInfoUpdate() {
@@ skipping 13 matching lines @@
 void FingerprintDataLoader::OnGotPlugins(
     const std::vector<webkit::WebPluginInfo>& plugins) {
   DCHECK(!has_loaded_plugins_);
   has_loaded_plugins_ = true;
   plugins_ = plugins;
   MaybeFillFingerprint();
 }
 
 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_) {
+  bool finished = gpu_data_manager_->IsCompleteGpuInfoAvailable() && fonts_;
+#if defined(USE_PLUGINS)
+  finished = finished && has_loaded_plugins_;
+#endif
+  if (finished) {
     FillFingerprint();
     delete this;
   }
 }
 
 void FingerprintDataLoader::FillFingerprint() {
   scoped_ptr<Fingerprint> fingerprint(new Fingerprint);
   Fingerprint_MachineCharacteristics* machine =
       fingerprint->mutable_machine_characteristics();
 
@@ skipping 30 matching lines @@
   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.
 
   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_obfuscated_gaia_id(obfuscated_gaia_id_);
   metadata->set_fingerprinter_version(kFingerprinterVersion);
 
   callback_.Run(fingerprint.Pass());
 }
 
 }  // namespace
 
 void GetFingerprint(
-    int64 gaia_id,
+    uint64 obfuscated_gaia_id,
     const gfx::Rect& window_bounds,
     const content::WebContents& web_contents,
     const std::string& version,
     const std::string& charset,
     const std::string& accept_languages,
     const base::Time& install_time,
     DialogType dialog_type,
     const std::string& app_locale,
     const base::Callback<void(scoped_ptr<Fingerprint>)>& callback) {
   gfx::Rect content_bounds;
   web_contents.GetView()->GetContainerBounds(&content_bounds);
 
   WebKit::WebScreenInfo screen_info;
   content::RenderWidgetHostView* host_view =
       web_contents.GetRenderWidgetHostView();
   if (host_view)
     host_view->GetRenderWidgetHost()->GetWebScreenInfo(&screen_info);
 
   internal::GetFingerprintInternal(
-      gaia_id, window_bounds, content_bounds, screen_info, version, charset,
-      accept_languages, install_time, dialog_type, app_locale, callback);
+      obfuscated_gaia_id, window_bounds, content_bounds, screen_info, version,
+      charset, accept_languages, install_time, dialog_type, app_locale,
+      callback);
 }
 
 namespace internal {
 
 void GetFingerprintInternal(
-    int64 gaia_id,
+    uint64 obfuscated_gaia_id,
     const gfx::Rect& window_bounds,
     const gfx::Rect& content_bounds,
     const WebKit::WebScreenInfo& screen_info,
     const std::string& version,
     const std::string& charset,
     const std::string& accept_languages,
     const base::Time& install_time,
     DialogType dialog_type,
     const std::string& app_locale,
     const base::Callback<void(scoped_ptr<Fingerprint>)>& callback) {
   // Begin loading all of the data that we need to load asynchronously.
   // 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);
+  new FingerprintDataLoader(obfuscated_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