Move webplugininfo.h to content/public.

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 17 matching lines @@
 #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/webplugininfo.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/gfx/rect.h"
 #include "ui/gfx/screen.h"
-#include "webkit/plugins/webplugininfo.h"
 
 using WebKit::WebScreenInfo;
 
 namespace autofill {
 namespace risk {
 
 namespace {
 
 const int32 kFingerprinterVersion = 1;
 
@@ skipping 41 matching lines @@
 
     std::string font_name;
     success = font_description->GetString(1, &font_name);
     DCHECK(success);
 
     machine->add_font(font_name);
   }
 }
 
 // Adds the list of |plugins| to the |machine|.
-void AddPluginsToFingerprint(const std::vector<webkit::WebPluginInfo>& plugins,
+void AddPluginsToFingerprint(const std::vector<content::WebPluginInfo>& plugins,
                              Fingerprint::MachineCharacteristics* machine) {
-  for (std::vector<webkit::WebPluginInfo>::const_iterator it = plugins.begin();
+  for (std::vector<content::WebPluginInfo>::const_iterator it = plugins.begin();
        it != plugins.end(); ++it) {
     Fingerprint::MachineCharacteristics::Plugin* plugin =
         machine->add_plugin();
     plugin->set_name(UTF16ToUTF8(it->name));
     plugin->set_description(UTF16ToUTF8(it->desc));
-    for (std::vector<webkit::WebPluginMimeType>::const_iterator mime_type =
+    for (std::vector<content::WebPluginMimeType>::const_iterator mime_type =
              it->mime_types.begin();
          mime_type != it->mime_types.end(); ++mime_type) {
       plugin->add_mime_type(mime_type->mime_type);
     }
     plugin->set_version(UTF16ToUTF8(it->version));
   }
 }
 
 // Adds the list of HTTP accept languages to the |machine|.
 void AddAcceptLanguagesToFingerprint(
@@ skipping 82 matching lines @@
       const base::Callback<void(scoped_ptr<Fingerprint>)>& callback);
 
  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 OnGotPlugins(const std::vector<content::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();
@@ skipping 20 matching lines @@
   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_;
+  std::vector<content::WebPluginInfo> plugins_;
   bool waiting_on_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 59 matching lines @@
   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) {
+    const std::vector<content::WebPluginInfo>& plugins) {
   DCHECK(waiting_on_plugins_);
   waiting_on_plugins_ = false;
   plugins_ = plugins;
   MaybeFillFingerprint();
 }
 
 void FingerprintDataLoader::OnGotGeoposition(
     const content::Geoposition& geoposition) {
   DCHECK(!geoposition_.Validate());
 
@@ skipping 148 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, dialog_type, app_locale,
       callback);
 }
 
 }  // namespace risk
 }  // namespace autofill