Reland 2:Geolocation: move from content/browser to device/

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 12 matching lines @@
 #include "base/scoped_observer.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "base/values.h"
 #include "components/autofill/content/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/common/geoposition.h"
 #include "content/public/common/webplugininfo.h"
+#include "device/geolocation/geolocation_provider.h"
+#include "device/geolocation/geoposition.h"
 #include "gpu/config/gpu_info.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebScreenInfo.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/geometry/rect.h"
 
 using blink::WebScreenInfo;
 
 namespace autofill {
@@ skipping 141 matching lines @@
 
  private:
   ~FingerprintDataLoader() override {}
 
   // content::GpuDataManagerObserver:
   void OnGpuInfoUpdate() override;
 
   // Callbacks for asynchronously loaded data.
   void OnGotFonts(std::unique_ptr<base::ListValue> fonts);
   void OnGotPlugins(const std::vector<content::WebPluginInfo>& plugins);
-  void OnGotGeoposition(const content::Geoposition& geoposition);
+  void OnGotGeoposition(const device::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.
   // Weak reference because the GpuDataManager class is a singleton.
@@ skipping 13 matching lines @@
   const std::string charset_;
   const std::string accept_languages_;
   const std::string app_locale_;
   const std::string user_agent_;
   const base::Time install_time_;
 
   // Data that will be loaded asynchronously.
   std::unique_ptr<base::ListValue> fonts_;
   std::vector<content::WebPluginInfo> plugins_;
   bool waiting_on_plugins_;
-  content::Geoposition geoposition_;
+  device::Geoposition geoposition_;
 
   // Timer to enforce a maximum timeout before the |callback_| is called, even
   // if not all asynchronous data has been loaded.
   base::OneShotTimer timeout_timer_;
 
   // The callback that will be called once all the data is available.
   base::Callback<void(std::unique_ptr<Fingerprint>)> callback_;
 
   // The callback used as an "observer" of the GeolocationProvider.
-  std::unique_ptr<content::GeolocationProvider::Subscription>
+  std::unique_ptr<device::GeolocationProvider::Subscription>
       geolocation_subscription_;
 
   // For invalidating asynchronous callbacks that might arrive after |this|
   // instance is destroyed.
   base::WeakPtrFactory<FingerprintDataLoader> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FingerprintDataLoader);
 };
 
 FingerprintDataLoader::FingerprintDataLoader(
@@ skipping 45 matching lines @@
 #else
   waiting_on_plugins_ = false;
 #endif
 
   // Load font data.
   content::GetFontListAsync(
       base::Bind(&FingerprintDataLoader::OnGotFonts,
                  weak_ptr_factory_.GetWeakPtr()));
 
   // Load geolocation data.
-  geolocation_subscription_ = content::GeolocationProvider::GetInstance()->
+  geolocation_subscription_ = device::GeolocationProvider::GetInstance()->
       AddLocationUpdateCallback(
           base::Bind(&FingerprintDataLoader::OnGotGeoposition,
                       weak_ptr_factory_.GetWeakPtr()),
           false);
 }
 
 void FingerprintDataLoader::OnGpuInfoUpdate() {
   if (!gpu_data_manager_->IsEssentialGpuInfoAvailable())
     return;
 
   gpu_observer_.Remove(gpu_data_manager_);
   MaybeFillFingerprint();
 }
 
 void FingerprintDataLoader::OnGotFonts(std::unique_ptr<base::ListValue> fonts) {
   DCHECK(!fonts_);
   fonts_.reset(fonts.release());
   MaybeFillFingerprint();
 }
 
 void FingerprintDataLoader::OnGotPlugins(
     const std::vector<content::WebPluginInfo>& plugins) {
   DCHECK(waiting_on_plugins_);
   waiting_on_plugins_ = false;
   plugins_ = plugins;
   MaybeFillFingerprint();
 }
 
 void FingerprintDataLoader::OnGotGeoposition(
-    const content::Geoposition& geoposition) {
+    const device::Geoposition& geoposition) {
   DCHECK(!geoposition_.Validate());
 
   geoposition_ = geoposition;
   DCHECK(geoposition_.Validate() ||
-         geoposition_.error_code != content::Geoposition::ERROR_CODE_NONE);
+         geoposition_.error_code != device::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_->IsEssentialGpuInfoAvailable()) &&
        fonts_ &&
        !waiting_on_plugins_ &&
        (geoposition_.Validate() ||
-        geoposition_.error_code != content::Geoposition::ERROR_CODE_NONE))) {
+        geoposition_.error_code != device::Geoposition::ERROR_CODE_NONE))) {
     FillFingerprint();
     delete this;
   }
 }
 
 void FingerprintDataLoader::FillFingerprint() {
   std::unique_ptr<Fingerprint> fingerprint(new Fingerprint);
   Fingerprint::MachineCharacteristics* machine =
       fingerprint->mutable_machine_characteristics();
 
@@ skipping 29 matching lines @@
   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 more user behavior data.
   if (geoposition_.Validate() &&
-      geoposition_.error_code == content::Geoposition::ERROR_CODE_NONE) {
+      geoposition_.error_code == device::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());
   }
 
@@ skipping 53 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