Change blink::WebScreenInfo to content::ScreenInfo

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 18 matching lines @@
 #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/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/screen_info.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 {
 namespace risk {
 
 namespace {
 
 const int32_t kFingerprinterVersion = 1;
 
 // Maximum amount of time, in seconds, to wait for loading asynchronous
 // fingerprint data.
 const int kTimeoutSeconds = 4;
@@ skipping 61 matching lines @@
     machine->add_requested_language(lang);
 }
 
 // This function writes
 //   (a) the number of screens,
 //   (b) the primary display's screen size,
 //   (c) the screen's color depth, and
 //   (d) the size of the screen unavailable to web page content,
 //       i.e. the Taskbar size on Windows
 // into the |machine|.
-void AddScreenInfoToFingerprint(const WebScreenInfo& screen_info,
+void AddScreenInfoToFingerprint(const content::ScreenInfo& screen_info,
                                 Fingerprint::MachineCharacteristics* machine) {
   machine->set_screen_count(display::Screen::GetScreen()->GetNumDisplays());
 
   const gfx::Size screen_size =
       display::Screen::GetScreen()->GetPrimaryDisplay().GetSizeInPixel();
   machine->mutable_screen_size()->set_width(screen_size.width());
   machine->mutable_screen_size()->set_height(screen_size.height());
 
   machine->set_screen_color_depth(screen_info.depth);
 
   const gfx::Rect screen_rect(screen_info.rect);
-  const gfx::Rect available_rect(screen_info.availableRect);
+  const gfx::Rect available_rect(screen_info.available_rect);
   const gfx::Rect unavailable_rect =
       gfx::SubtractRects(screen_rect, available_rect);
   machine->mutable_unavailable_screen_size()->set_width(
       unavailable_rect.width());
   machine->mutable_unavailable_screen_size()->set_height(
       unavailable_rect.height());
 }
 
 // Writes info about the machine's CPU into the |machine|.
 void AddCpuInfoToFingerprint(Fingerprint::MachineCharacteristics* machine) {
@@ skipping 19 matching lines @@
 }
 
 // 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_t obfuscated_gaia_id,
       const gfx::Rect& window_bounds,
       const gfx::Rect& content_bounds,
-      const WebScreenInfo& screen_info,
+      const content::ScreenInfo& screen_info,
       const std::string& version,
       const std::string& charset,
       const std::string& accept_languages,
       const base::Time& install_time,
       const std::string& app_locale,
       const std::string& user_agent,
       const base::TimeDelta& timeout,
       const base::Callback<void(std::unique_ptr<Fingerprint>)>& callback);
 
  private:
@@ skipping 20 matching lines @@
 
   // Ensures that any observer registrations for the GPU data are cleaned up by
   // the time this object is destroyed.
   ScopedObserver<content::GpuDataManager, FingerprintDataLoader> gpu_observer_;
 
   // Data that will be passed on to the next loading phase.  See the comment for
   // GetFingerprint() for a description of these variables.
   const uint64_t obfuscated_gaia_id_;
   const gfx::Rect window_bounds_;
   const gfx::Rect content_bounds_;
-  const WebScreenInfo screen_info_;
+  const content::ScreenInfo screen_info_;
   const std::string version_;
   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_;
@@ skipping 15 matching lines @@
   // instance is destroyed.
   base::WeakPtrFactory<FingerprintDataLoader> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FingerprintDataLoader);
 };
 
 FingerprintDataLoader::FingerprintDataLoader(
     uint64_t obfuscated_gaia_id,
     const gfx::Rect& window_bounds,
     const gfx::Rect& content_bounds,
-    const WebScreenInfo& screen_info,
+    const content::ScreenInfo& screen_info,
     const std::string& version,
     const std::string& charset,
     const std::string& accept_languages,
     const base::Time& install_time,
     const std::string& app_locale,
     const std::string& user_agent,
     const base::TimeDelta& timeout,
     const base::Callback<void(std::unique_ptr<Fingerprint>)>& callback)
     : gpu_data_manager_(content::GpuDataManager::GetInstance()),
       gpu_observer_(this),
@@ skipping 159 matching lines @@
 }
 
 }  // namespace
 
 namespace internal {
 
 void GetFingerprintInternal(
     uint64_t obfuscated_gaia_id,
     const gfx::Rect& window_bounds,
     const gfx::Rect& content_bounds,
-    const blink::WebScreenInfo& screen_info,
+    const content::ScreenInfo& screen_info,
     const std::string& version,
     const std::string& charset,
     const std::string& accept_languages,
     const base::Time& install_time,
     const std::string& app_locale,
     const std::string& user_agent,
     const base::TimeDelta& timeout,
     const base::Callback<void(std::unique_ptr<Fingerprint>)>& callback) {
   // Begin loading all of the data that we need to load asynchronously.
   // This class is responsible for freeing its own memory.
@@ skipping 11 matching lines @@
     content::WebContents* web_contents,
     const std::string& version,
     const std::string& charset,
     const std::string& accept_languages,
     const base::Time& install_time,
     const std::string& app_locale,
     const std::string& user_agent,
     const base::Callback<void(std::unique_ptr<Fingerprint>)>& callback) {
   gfx::Rect content_bounds = web_contents->GetContainerBounds();
 
-  blink::WebScreenInfo screen_info;
+  content::ScreenInfo screen_info;
   const content::RenderWidgetHostView* host_view =
       web_contents->GetRenderWidgetHostView();
   if (host_view)
-    host_view->GetRenderWidgetHost()->GetWebScreenInfo(&screen_info);
+    host_view->GetRenderWidgetHost()->GetScreenInfo(&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