rAc: Get rid of dialog type in rAc, there is only one type left now.

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 50 matching lines @@
   return base::Time::FromUTCExploded(local) - utc;
 }
 
 // Returns the concatenation of the operating system name and version, e.g.
 // "Mac OS X 10.6.8".
 std::string GetOperatingSystemVersion() {
   return base::SysInfo::OperatingSystemName() + " " +
       base::SysInfo::OperatingSystemVersion();
 }
 
-Fingerprint::MachineCharacteristics::BrowserFeature
-    DialogTypeToBrowserFeature(DialogType dialog_type) {
-  switch (dialog_type) {
-    case DIALOG_TYPE_AUTOCHECKOUT:
-      return Fingerprint::MachineCharacteristics::FEATURE_AUTOCHECKOUT;
-
-    case DIALOG_TYPE_REQUEST_AUTOCOMPLETE:
-      return Fingerprint::MachineCharacteristics::FEATURE_REQUEST_AUTOCOMPLETE;
-  }
-
-  NOTREACHED();
-  return Fingerprint::MachineCharacteristics::FEATURE_UNKNOWN;
-}
-
 // Adds the list of |fonts| to the |machine|.
 void AddFontsToFingerprint(const base::ListValue& fonts,
                            Fingerprint::MachineCharacteristics* machine) {
   for (base::ListValue::const_iterator it = fonts.begin();
        it != fonts.end(); ++it) {
     // Each item in the list is a two-element list such that the first element
     // is the font family and the second is the font name.
     const base::ListValue* font_description = NULL;
     bool success = (*it)->GetAsList(&font_description);
     DCHECK(success);
@@ skipping 99 matching lines @@
  public:
   FingerprintDataLoader(
       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);
 
  private:
   virtual ~FingerprintDataLoader() {}
 
   // content::GpuDataManagerObserver:
   virtual void OnGpuInfoUpdate() OVERRIDE;
 
   // Callbacks for asynchronously loaded data.
@@ skipping 28 matching lines @@
   // Data that will be passed on to the next loading phase.  See the comment for
   // GetFingerprint() for a description of these variables.
   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<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);
 };
 
 FingerprintDataLoader::FingerprintDataLoader(
     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()),
       gpu_observer_(this),
       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),
       waiting_on_plugins_(true),
       callback_(callback) {
   DCHECK(!install_time_.is_null());
 
   // Load GPU data if needed.
   if (!gpu_data_manager_->IsCompleteGpuInfoAvailable()) {
     gpu_observer_.Add(gpu_data_manager_);
     gpu_data_manager_->RequestCompleteGpuInfoIfNeeded();
   }
 
@@ skipping 94 matching lines @@
   machine->set_operating_system_build(GetOperatingSystemVersion());
   // We use the delta between the install time and the Unix epoch, in hours.
   machine->set_browser_install_time_hours(
       (install_time_ - base::Time::UnixEpoch()).InHours());
   machine->set_utc_offset_ms(GetTimezoneOffset().InMilliseconds());
   machine->set_browser_language(app_locale_);
   machine->set_charset(charset_);
   machine->set_user_agent(content::GetUserAgent(GURL()));
   machine->set_ram(base::SysInfo::AmountOfPhysicalMemory());
   machine->set_browser_build(version_);
-  machine->set_browser_feature(DialogTypeToBrowserFeature(dialog_type_));
+  machine->set_browser_feature(
+      Fingerprint::MachineCharacteristics::FEATURE_REQUEST_AUTOCOMPLETE);
   AddFontsToFingerprint(*fonts_, machine);
   AddPluginsToFingerprint(plugins_, machine);
   AddAcceptLanguagesToFingerprint(accept_languages_, machine);
   AddScreenInfoToFingerprint(screen_info_, machine);
   AddCpuInfoToFingerprint(machine);
   AddGpuInfoToFingerprint(machine);
 
   // TODO(isherman): Record the user_and_device_name_hash.
   // TODO(isherman): Record the partition size of the hard drives?
 
@@ skipping 38 matching lines @@
 
 void GetFingerprintInternal(
     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(obfuscated_gaia_id, window_bounds, content_bounds,
                             screen_info, version, charset, accept_languages,
-                            install_time, dialog_type, app_locale, callback);
+                            install_time, app_locale, callback);
 }
 
 }  // namespace internal
 
 void GetFingerprint(
     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(
       obfuscated_gaia_id, window_bounds, content_bounds, screen_info, version,
-      charset, accept_languages, install_time, dialog_type, app_locale,
-      callback);
+      charset, accept_languages, install_time, app_locale, callback);
 }
 
 }  // namespace risk
 }  // namespace autofill