[Autofill] Add Chrome flag that annotates web forms with form and field signatures

components/autofill/content/renderer/password_autofill_agent.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.
 
 #include "components/autofill/content/renderer/password_autofill_agent.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/i18n/case_conversion.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "components/autofill/content/renderer/form_autofill_util.h"
 #include "components/autofill/content/renderer/password_form_conversion_utils.h"
 #include "components/autofill/content/renderer/renderer_save_password_progress_logger.h"
 #include "components/autofill/core/common/autofill_constants.h"
+#include "components/autofill/core/common/autofill_switches.h"
 #include "components/autofill/core/common/autofill_util.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "components/autofill/core/common/password_form_fill_data.h"
 #include "components/security_state/core/security_state.h"
 #include "content/public/common/origin_util.h"
 #include "content/public/renderer/document_state.h"
 #include "content/public/renderer/navigation_state.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
@@ skipping 15 matching lines @@
 
 namespace autofill {
 namespace {
 
 // The size above which we stop triggering autocomplete.
 static const size_t kMaximumTextSizeForAutocomplete = 1000;
 
 const char kDummyUsernameField[] = "anonymous_username";
 const char kDummyPasswordField[] = "anonymous_password";
 
+const char kDebugAttributeForFormSignature[] = "form_signature";
+const char kDebugAttributeForFieldSignature[] = "field_signature";
+
 // Maps element names to the actual elements to simplify form filling.
 typedef std::map<base::string16, blink::WebInputElement> FormInputElementMap;
 
 // Use the shorter name when referencing SavePasswordProgressLogger::StringID
 // values to spare line breaks. The code provides enough context for that
 // already.
 typedef SavePasswordProgressLogger Logger;
 
 typedef std::vector<FormInputElementMap> FormElementsList;
 
@@ skipping 482 matching lines @@
   }
 
   // Fill if we have an exact match for the username. Note that this sets
   // username to autofilled.
   return FillUserNameAndPassword(
       &username_element, &password_element, fill_data,
       true /* exact_username_match */, false /* set_selection */,
       field_value_and_properties_map, registration_callback, logger);
 }
 
+void AnnotateFormsWithSignatures(

[sebsg, 2017/02/17 16:19:57]

Can you just add a small comment here to explain the general idea and what it
annotates? :)

[kolos1, 2017/02/20 10:04:54]

Done.

+    blink::WebVector<blink::WebFormElement> forms) {
+  for (blink::WebFormElement form : forms) {
+    std::unique_ptr<PasswordForm> password_form(
+        CreatePasswordFormFromWebForm(form, nullptr, nullptr));
+    if (password_form) {
+      form.setAttribute(
+          blink::WebString::fromASCII(kDebugAttributeForFormSignature),
+          blink::WebString::fromUTF8(base::Uint64ToString(
+              CalculateFormSignature(password_form->form_data))));
+      blink::WebVector<blink::WebFormControlElement> control_elements =
+          form_util::ExtractAutofillableElementsInForm(form);
+      CHECK(control_elements.size() == password_form->form_data.fields.size());
+      for (size_t i = 0; i < control_elements.size(); ++i) {
+        blink::WebFormControlElement& control_element = control_elements[i];
+        if (!form_util::IsAutofillableElement(control_element))
+          continue;
+
+        const FormFieldData& field = password_form->form_data.fields[i];
+        CHECK(field.name == control_element.nameForAutofill().utf16());
+        control_element.setAttribute(
+            blink::WebString::fromASCII(kDebugAttributeForFieldSignature),
+            blink::WebString::fromUTF8(
+                base::Uint64ToString(CalculateFieldSignatureForField(field))));
+      }
+    }
+  }
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // PasswordAutofillAgent, public:
 
 PasswordAutofillAgent::PasswordAutofillAgent(content::RenderFrame* render_frame)
     : content::RenderFrameObserver(render_frame),
       logging_state_active_(false),
       was_username_autofilled_(false),
       was_password_autofilled_(false),
@@ skipping 402 matching lines @@
   // Checks whether the webpage is a redirect page or an empty page.
   if (form_util::IsWebpageEmpty(frame)) {
     if (logger) {
       logger->LogMessage(Logger::STRING_WEBPAGE_EMPTY);
     }
     return;
   }
 
   blink::WebVector<blink::WebFormElement> forms;
   frame->document().forms(forms);
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kShowAutofillSignatures)) {
+    AnnotateFormsWithSignatures(forms);
+  }
   if (logger)
     logger->LogNumber(Logger::STRING_NUMBER_OF_ALL_FORMS, forms.size());
 
   std::vector<PasswordForm> password_forms;
   for (const blink::WebFormElement& form : forms) {
     if (only_visible) {
       bool is_form_visible = form_util::AreFormContentsVisible(form);
       if (logger) {
         LogHTMLForm(logger.get(), Logger::STRING_FORM_FOUND_ON_PAGE, form);
         logger->LogBoolean(Logger::STRING_FORM_IS_VISIBLE, is_form_visible);
@@ skipping 519 matching lines @@
 PasswordAutofillAgent::GetPasswordManagerDriver() {
   if (!password_manager_driver_) {
     render_frame()->GetRemoteInterfaces()->GetInterface(
         mojo::MakeRequest(&password_manager_driver_));
   }
 
   return password_manager_driver_;
 }
 
 }  // namespace autofill