components/autofill: scoped_ptr -> unique_ptr

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>

[Mathieu, 2016/04/04 13:36:16]

it's also been included in the .h for this file. In other files in this CL, this
.cc include would be omitted. We should be consistent and pick one.

[vabr (Chromium), 2016/04/04 14:29:04]

My reason to keep this here:
There are 2 kinds of unique_ptr usage in this file:
(A) As on line 1195, in a method signature coming from the .h file.
(B) As on line 131, as an implementation detail.

For (A) I would not #include <memory> in the .cc, but for (B) I would. The
reason is: if the header eliminates the unique_ptr (and the #include), the .cc
file still needs it because of (B). In most cases, the compiler would throw an
error, but it mail fail to do so (if there are other indirect #include
<memory>), resulting in a broken IWYU.

Having said all of that, I'm not strongly opposed to not #including stuff that
is already in the header as a rule of thumb, if you see enough benefit in that.

 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/i18n/case_conversion.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "components/autofill/content/common/autofill_messages.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"
@@ skipping 96 matching lines @@
              ? IsPasswordField(field) ? base::ASCIIToUTF16(kDummyPasswordField)
                                       : base::ASCIIToUTF16(kDummyUsernameField)
              : field.name;
 }
 
 bool IsUnownedPasswordFormVisible(blink::WebFrame* frame,
                                   const GURL& action,
                                   const GURL& origin,
                                   const FormData& form_data,
                                   const FormsPredictionsMap& form_predictions) {
-  scoped_ptr<PasswordForm> unowned_password_form(
+  std::unique_ptr<PasswordForm> unowned_password_form(
       CreatePasswordFormFromUnownedInputElements(*frame, nullptr,
                                                  &form_predictions));
   if (!unowned_password_form)
     return false;
   std::vector<blink::WebFormControlElement> control_elements =
       form_util::GetUnownedAutofillableFormFieldElements(
           frame->document().all(), nullptr);
   if (!form_util::IsSomeControlElementVisible(control_elements))
     return false;
 
@@ skipping 600 matching lines @@
   if (!element_frame)
     return;
   DCHECK_EQ(element_frame, render_frame()->GetWebFrame());
 
   // Some login forms have event handlers that put a hash of the password into
   // a hidden field and then clear the password (http://crbug.com/28910,
   // http://crbug.com/391693). This method gets called before any of those
   // handlers run, so save away a copy of the password in case it gets lost.
   // To honor the user having explicitly cleared the password, even an empty
   // password will be saved here.
-  scoped_ptr<PasswordForm> password_form;
+  std::unique_ptr<PasswordForm> password_form;
   if (element.form().isNull()) {
     password_form = CreatePasswordFormFromUnownedInputElements(
         *element_frame, &nonscript_modified_values_, &form_predictions_);
   } else {
     password_form = CreatePasswordFormFromWebForm(
         element.form(), &nonscript_modified_values_, &form_predictions_);
   }
   ProvisionallySavePassword(std::move(password_form), RESTRICTION_NONE);
 
   if (element.isPasswordField()) {
@@ skipping 199 matching lines @@
   Send(new AutofillHostMsg_InPageNavigation(routing_id(),
                                             *provisionally_saved_form_));
   provisionally_saved_form_.reset();
 }
 
 void PasswordAutofillAgent::FirstUserGestureObserved() {
   gatekeeper_.OnUserGesture();
 }
 
 void PasswordAutofillAgent::SendPasswordForms(bool only_visible) {
-  scoped_ptr<RendererSavePasswordProgressLogger> logger;
+  std::unique_ptr<RendererSavePasswordProgressLogger> logger;
   if (logging_state_active_) {
     logger.reset(new RendererSavePasswordProgressLogger(this, routing_id()));
     logger->LogMessage(Logger::STRING_SEND_PASSWORD_FORMS_METHOD);
     logger->LogBoolean(Logger::STRING_ONLY_VISIBLE, only_visible);
   }
 
   blink::WebFrame* frame = render_frame()->GetWebFrame();
   // Make sure that this security origin is allowed to use password manager.
   blink::WebSecurityOrigin origin = frame->document().getSecurityOrigin();
   if (logger) {
@@ skipping 28 matching lines @@
         LogHTMLForm(logger.get(), Logger::STRING_FORM_FOUND_ON_PAGE, form);
         logger->LogBoolean(Logger::STRING_FORM_IS_VISIBLE, is_form_visible);
       }
 
       // If requested, ignore non-rendered forms, e.g., those styled with
       // display:none.
       if (!is_form_visible)
         continue;
     }
 
-    scoped_ptr<PasswordForm> password_form(
+    std::unique_ptr<PasswordForm> password_form(
         CreatePasswordFormFromWebForm(form, nullptr, &form_predictions_));
     if (password_form) {
       if (logger) {
         logger->LogPasswordForm(Logger::STRING_FORM_IS_PASSWORD,
                                 *password_form);
       }
       password_forms.push_back(*password_form);
     }
   }
 
   // See if there are any unattached input elements that could be used for
   // password submission.
   bool add_unowned_inputs = true;
   if (only_visible) {
     std::vector<blink::WebFormControlElement> control_elements =
         form_util::GetUnownedAutofillableFormFieldElements(
             frame->document().all(), nullptr);
     add_unowned_inputs =
         form_util::IsSomeControlElementVisible(control_elements);
     if (logger) {
       logger->LogBoolean(Logger::STRING_UNOWNED_INPUTS_VISIBLE,
                          add_unowned_inputs);
     }
   }
   if (add_unowned_inputs) {
-    scoped_ptr<PasswordForm> password_form(
+    std::unique_ptr<PasswordForm> password_form(
         CreatePasswordFormFromUnownedInputElements(*frame, nullptr,
                                                    &form_predictions_));
     if (password_form) {
       if (logger) {
         logger->LogPasswordForm(Logger::STRING_FORM_IS_PASSWORD,
                                 *password_form);
       }
       password_forms.push_back(*password_form);
     }
   }
@@ skipping 75 matching lines @@
   // and uses the candidate stored in |provisionally_saved_form_|.
   //
   // User-typed password will get stored to |provisionally_saved_form_| in
   // TextDidChangeInTextField. Autofilled or JavaScript-copied passwords need to
   // be saved here.
   //
   // Only non-empty passwords are saved here. Empty passwords were likely
   // cleared by some scripts (http://crbug.com/28910, http://crbug.com/391693).
   // Had the user cleared the password, |provisionally_saved_form_| would
   // already have been updated in TextDidChangeInTextField.
-  scoped_ptr<PasswordForm> password_form = CreatePasswordFormFromWebForm(
+  std::unique_ptr<PasswordForm> password_form = CreatePasswordFormFromWebForm(
       form, &nonscript_modified_values_, &form_predictions_);
   ProvisionallySavePassword(std::move(password_form),
                             RESTRICTION_NON_EMPTY_PASSWORD);
 }
 
 void PasswordAutofillAgent::WillSubmitForm(const blink::WebFormElement& form) {
-  scoped_ptr<RendererSavePasswordProgressLogger> logger;
+  std::unique_ptr<RendererSavePasswordProgressLogger> logger;
   if (logging_state_active_) {
     logger.reset(new RendererSavePasswordProgressLogger(this, routing_id()));
     logger->LogMessage(Logger::STRING_WILL_SUBMIT_FORM_METHOD);
     LogHTMLForm(logger.get(), Logger::STRING_HTML_FORM_FOR_SUBMIT, form);
   }
 
-  scoped_ptr<PasswordForm> submitted_form =
-      CreatePasswordFormFromWebForm(form, &nonscript_modified_values_,
-                                    &form_predictions_);
+  std::unique_ptr<PasswordForm> submitted_form = CreatePasswordFormFromWebForm(
+      form, &nonscript_modified_values_, &form_predictions_);
 
   // If there is a provisionally saved password, copy over the previous
   // password value so we get the user's typed password, not the value that
   // may have been transformed for submit.
   // TODO(gcasto): Do we need to have this action equality check? Is it trying
   // to prevent accidentally copying over passwords from a different form?
   if (submitted_form) {
     if (logger) {
       logger->LogPasswordForm(Logger::STRING_CREATED_PASSWORD_FORM,
                               *submitted_form);
@@ skipping 16 matching lines @@
     // we will never get to finish the load.
     Send(new AutofillHostMsg_PasswordFormSubmitted(routing_id(),
                                                    *submitted_form));
     provisionally_saved_form_.reset();
   } else if (logger) {
     logger->LogMessage(Logger::STRING_FORM_IS_NOT_PASSWORD);
   }
 }
 
 void PasswordAutofillAgent::DidStartProvisionalLoad() {
-  scoped_ptr<RendererSavePasswordProgressLogger> logger;
+  std::unique_ptr<RendererSavePasswordProgressLogger> logger;
   if (logging_state_active_) {
     logger.reset(new RendererSavePasswordProgressLogger(this, routing_id()));
     logger->LogMessage(Logger::STRING_DID_START_PROVISIONAL_LOAD_METHOD);
   }
 
   const blink::WebLocalFrame* navigated_frame = render_frame()->GetWebFrame();
   if (navigated_frame->parent()) {
     if (logger)
       logger->LogMessage(Logger::STRING_FRAME_NOT_MAIN_FRAME);
     return;
@@ skipping 143 matching lines @@
 void PasswordAutofillAgent::OnSetLoggingState(bool active) {
   logging_state_active_ = active;
 }
 
 void PasswordAutofillAgent::OnAutofillUsernameAndPasswordDataReceived(
     const FormsPredictionsMap& predictions) {
   form_predictions_.insert(predictions.begin(), predictions.end());
 }
 
 void PasswordAutofillAgent::OnFindFocusedPasswordForm() {
-  scoped_ptr<PasswordForm> password_form;
+  std::unique_ptr<PasswordForm> password_form;
 
   blink::WebElement element = render_frame()->GetFocusedElement();
   if (!element.isNull() && element.hasHTMLTagName("input")) {
     blink::WebInputElement input = element.to<blink::WebInputElement>();
     if (input.isPasswordField() && !input.form().isNull()) {
       if (!input.form().isNull()) {
         password_form = CreatePasswordFormFromWebForm(
             input.form(), &nonscript_modified_values_, &form_predictions_);
       } else {
         password_form = CreatePasswordFormFromUnownedInputElements(
@@ skipping 119 matching lines @@
     username->setSelectionRange(username_query_prefix_.length(),
                                 username->value().length());
   }
   if (!password->suggestedValue().isEmpty()) {
       password->setSuggestedValue(blink::WebString());
       password->setAutofilled(was_password_autofilled_);
   }
 }
 
 void PasswordAutofillAgent::ProvisionallySavePassword(
-    scoped_ptr<PasswordForm> password_form,
+    std::unique_ptr<PasswordForm> password_form,
     ProvisionallySaveRestriction restriction) {
   if (!password_form || (restriction == RESTRICTION_NON_EMPTY_PASSWORD &&
                          password_form->password_value.empty() &&
                          password_form->new_password_value.empty())) {
     return;
   }
   provisionally_saved_form_ = std::move(password_form);
 }
 
 bool PasswordAutofillAgent::ProvisionallySavedPasswordIsValid() {
   return provisionally_saved_form_ &&
          !provisionally_saved_form_->username_value.empty() &&
          !(provisionally_saved_form_->password_value.empty() &&
          provisionally_saved_form_->new_password_value.empty());
 }
 
 }  // namespace autofill