[Autofill Assistant] Rename namespace to snake case

The namespace was in CamelCase by accident.

Bug: b/168107066
Change-Id: Id434bc76aebe2d6c548b61a218e01bbd1772e34d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2461120Reviewed-by: Luca Hunkeler <hluca@google.com>
Reviewed-by: Clemens Arbesser <arbesser@google.com>
Commit-Queue: Sandro Maggi <sandromaggi@google.com>
Cr-Commit-Position: refs/heads/master@{#815543}

components/autofill_assistant/browser/actions/action_delegate_util.cc

@@ -11,7 +11,7 @@
 #include "components/autofill_assistant/browser/web/element_finder.h"
 
 namespace autofill_assistant {
-namespace ActionDelegateUtil {
+namespace action_delegate_util {
 namespace {
 
 void RetainElementAndExecuteCallback(
@@ -112,14 +112,15 @@ void FindElementAndPerform(ActionDelegate* delegate,
                            base::OnceCallback<void(const ClientStatus&)> done) {
   auto actions = std::make_unique<ElementActionVector>();
   actions->emplace_back(std::move(perform));
-  FindElementAndPerform(delegate, selector, std::move(actions),
-                        std::move(done));
+  FindElementAndPerformAll(delegate, selector, std::move(actions),
+                           std::move(done));
 }
 
-void FindElementAndPerform(ActionDelegate* delegate,
-                           const Selector& selector,
-                           std::unique_ptr<ElementActionVector> perform_actions,
-                           base::OnceCallback<void(const ClientStatus&)> done) {
+void FindElementAndPerformAll(
+    ActionDelegate* delegate,
+    const Selector& selector,
+    std::unique_ptr<ElementActionVector> perform_actions,
+    base::OnceCallback<void(const ClientStatus&)> done) {
   DCHECK(!selector.empty());
   VLOG(3) << __func__ << " " << selector;
   delegate->FindElement(
@@ -149,8 +150,8 @@ void ClickOrTapElement(ActionDelegate* delegate,
   actions->emplace_back(base::BindOnce(&ActionDelegate::ClickOrTapElement,
                                        delegate->GetWeakPtr(), click_type));
 
-  FindElementAndPerform(delegate, selector, std::move(actions),
-                        std::move(callback));
+  FindElementAndPerformAll(delegate, selector, std::move(actions),
+                           std::move(callback));
 }
 
 void SendKeyboardInput(ActionDelegate* delegate,
@@ -171,8 +172,8 @@ void SendKeyboardInput(ActionDelegate* delegate,
                                        delegate->GetWeakPtr(), codepoints,
                                        delay_in_millis));
 
-  FindElementAndPerform(delegate, selector, std::move(actions),
-                        std::move(callback));
+  FindElementAndPerformAll(delegate, selector, std::move(actions),
+                           std::move(callback));
 }
 
 void SetFieldValue(ActionDelegate* delegate,
@@ -192,5 +193,5 @@ void SetFieldValue(ActionDelegate* delegate,
       std::move(callback));
 }
 
-}  // namespace ActionDelegateUtil
+}  // namespace action_delegate_util
 }  // namespace autofill_assistant

components/autofill_assistant/browser/actions/action_delegate_util.h

@@ -11,7 +11,7 @@
 #include "components/autofill_assistant/browser/service.pb.h"
 
 namespace autofill_assistant {
-namespace ActionDelegateUtil {
+namespace action_delegate_util {
 
 using ElementActionCallback =
     base::OnceCallback<void(const ElementFinder::Result&,
@@ -38,7 +38,7 @@ void FindElementAndPerform(
 // immediately executes the |done| callback. If the resolution succeeds, it
 // executes the |perform_actions| callbacks in sequence with the element and
 // the |done| callback as arguments, while retaining the element.
-void FindElementAndPerform(
+void FindElementAndPerformAll(
     /* const */ ActionDelegate* delegate,
     const Selector& selector,
     std::unique_ptr<ElementActionVector> perform_actions,
@@ -74,7 +74,7 @@ void SetFieldValue(/* const */ ActionDelegate* delegate,
                    int key_press_delay_in_millisecond,
                    base::OnceCallback<void(const ClientStatus&)> callback);
 
-}  // namespace ActionDelegateUtil
+}  // namespace action_delegate_util
 }  // namespace autofill_assistant
 
 #endif  // COMPONENTS_AUTOFILL_ASSISTANT_BROWSER_ACTIONS_ACTION_DELEGATE_UTIL_H_

components/autofill_assistant/browser/actions/action_delegate_util_unittest.cc

@@ -12,6 +12,7 @@
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace autofill_assistant {
+namespace action_delegate_util {
 namespace {
 
 using ::base::test::RunOnceCallback;
@@ -55,12 +56,11 @@ TEST_F(ActionDelegateUtilTest, FindElementFails) {
   EXPECT_CALL(*this,
               MockDone(EqualsStatus(ClientStatus(ELEMENT_RESOLUTION_FAILED))));
 
-  ActionDelegateUtil::FindElementAndPerform(
-      &mock_action_delegate_, Selector({"#nothing"}),
-      base::BindOnce(&ActionDelegateUtilTest::MockAction,
-                     base::Unretained(this)),
-      base::BindOnce(&ActionDelegateUtilTest::MockDone,
-                     base::Unretained(this)));
+  FindElementAndPerform(&mock_action_delegate_, Selector({"#nothing"}),
+                        base::BindOnce(&ActionDelegateUtilTest::MockAction,
+                                       base::Unretained(this)),
+                        base::BindOnce(&ActionDelegateUtilTest::MockDone,
+                                       base::Unretained(this)));
 }
 
 TEST_F(ActionDelegateUtilTest, FindElementAndExecuteSingleAction) {
@@ -72,12 +72,11 @@ TEST_F(ActionDelegateUtilTest, FindElementAndExecuteSingleAction) {
       .WillOnce(RunOnceCallback<1>(OkClientStatus()));
   EXPECT_CALL(*this, MockDone(EqualsStatus(OkClientStatus())));
 
-  ActionDelegateUtil::FindElementAndPerform(
-      &mock_action_delegate_, expected_selector,
-      base::BindOnce(&ActionDelegateUtilTest::MockAction,
-                     base::Unretained(this)),
-      base::BindOnce(&ActionDelegateUtilTest::MockDone,
-                     base::Unretained(this)));
+  FindElementAndPerform(&mock_action_delegate_, expected_selector,
+                        base::BindOnce(&ActionDelegateUtilTest::MockAction,
+                                       base::Unretained(this)),
+                        base::BindOnce(&ActionDelegateUtilTest::MockDone,
+                                       base::Unretained(this)));
 }
 
 TEST_F(ActionDelegateUtilTest, FindElementAndExecuteMultipleActions) {
@@ -95,7 +94,7 @@ TEST_F(ActionDelegateUtilTest, FindElementAndExecuteMultipleActions) {
       .WillOnce(RunOnceCallback<2>(OkClientStatus()));
   EXPECT_CALL(*this, MockDone(EqualsStatus(OkClientStatus())));
 
-  auto actions = std::make_unique<ActionDelegateUtil::ElementActionVector>();
+  auto actions = std::make_unique<ElementActionVector>();
   actions->emplace_back(base::BindOnce(
       &ActionDelegateUtilTest::MockIndexedAction, base::Unretained(this), 1));
   actions->emplace_back(base::BindOnce(
@@ -103,10 +102,10 @@ TEST_F(ActionDelegateUtilTest, FindElementAndExecuteMultipleActions) {
   actions->emplace_back(base::BindOnce(
       &ActionDelegateUtilTest::MockIndexedAction, base::Unretained(this), 3));
 
-  ActionDelegateUtil::FindElementAndPerform(
-      &mock_action_delegate_, expected_selector, std::move(actions),
-      base::BindOnce(&ActionDelegateUtilTest::MockDone,
-                     base::Unretained(this)));
+  FindElementAndPerformAll(&mock_action_delegate_, expected_selector,
+                           std::move(actions),
+                           base::BindOnce(&ActionDelegateUtilTest::MockDone,
+                                          base::Unretained(this)));
 }
 
 TEST_F(ActionDelegateUtilTest, ActionDelegateDeletedDuringExecution) {
@@ -124,7 +123,7 @@ TEST_F(ActionDelegateUtilTest, ActionDelegateDeletedDuringExecution) {
   EXPECT_CALL(*mock_delegate, ScrollIntoView(_, _)).Times(0);
   EXPECT_CALL(*this, MockDone(_)).Times(0);
 
-  auto actions = std::make_unique<ActionDelegateUtil::ElementActionVector>();
+  auto actions = std::make_unique<ElementActionVector>();
   actions->emplace_back(
       base::BindOnce(&ActionDelegate::WaitForDocumentToBecomeInteractive,
                      mock_delegate->GetWeakPtr()));
@@ -139,10 +138,10 @@ TEST_F(ActionDelegateUtilTest, ActionDelegateDeletedDuringExecution) {
   actions->emplace_back(base::BindOnce(&ActionDelegate::ScrollIntoView,
                                        mock_delegate->GetWeakPtr()));
 
-  ActionDelegateUtil::FindElementAndPerform(
-      mock_delegate.get(), expected_selector, std::move(actions),
-      base::BindOnce(&ActionDelegateUtilTest::MockDone,
-                     base::Unretained(this)));
+  FindElementAndPerformAll(mock_delegate.get(), expected_selector,
+                           std::move(actions),
+                           base::BindOnce(&ActionDelegateUtilTest::MockDone,
+                                          base::Unretained(this)));
 }
 
 TEST_F(ActionDelegateUtilTest, FindElementForGetFails) {
@@ -154,7 +153,7 @@ TEST_F(ActionDelegateUtilTest, FindElementForGetFails) {
       *this,
       MockDoneGet(EqualsStatus(ClientStatus(ELEMENT_RESOLUTION_FAILED)), ""));
 
-  ActionDelegateUtil::FindElementAndGetProperty(
+  FindElementAndGetProperty(
       &mock_action_delegate_, Selector({"#nothing"}),
       base::BindOnce(&ActionDelegateUtilTest::MockGetAction,
                      base::Unretained(this)),
@@ -171,7 +170,7 @@ TEST_F(ActionDelegateUtilTest, FindElementAndGetProperty) {
       .WillOnce(RunOnceCallback<1>(OkClientStatus(), "value"));
   EXPECT_CALL(*this, MockDoneGet(EqualsStatus(OkClientStatus()), "value"));
 
-  ActionDelegateUtil::FindElementAndGetProperty(
+  FindElementAndGetProperty(
       &mock_action_delegate_, expected_selector,
       base::BindOnce(&ActionDelegateUtilTest::MockGetAction,
                      base::Unretained(this)),
@@ -180,4 +179,5 @@ TEST_F(ActionDelegateUtilTest, FindElementAndGetProperty) {
 }
 
 }  // namespace
+}  // namespace action_delegate_util
 }  // namespace autofill_assistant

components/autofill_assistant/browser/actions/click_action.cc

@@ -51,7 +51,7 @@ void ClickAction::OnWaitForElement(ProcessActionCallback callback,
     return;
   }
 
-  ActionDelegateUtil::ClickOrTapElement(
+  action_delegate_util::ClickOrTapElement(
       delegate_, selector, click_type_,
       base::BindOnce(&::autofill_assistant::ClickAction::OnClick,
                      weak_ptr_factory_.GetWeakPtr(), std::move(callback)));

components/autofill_assistant/browser/actions/fallback_handler/required_fields_fallback_handler.cc

@@ -225,7 +225,7 @@ void RequiredFieldsFallbackHandler::SetFallbackFieldValuesSequentially(
   const RequiredField& required_field = required_fields_[required_fields_index];
 
   if (required_field.value_expression.empty()) {
-    ActionDelegateUtil::SetFieldValue(
+    action_delegate_util::SetFieldValue(
         action_delegate_, required_field.selector, "",
         required_field.fill_strategy, required_field.delay_in_millisecond,
         base::BindOnce(&RequiredFieldsFallbackHandler::OnSetFallbackFieldValue,
@@ -249,7 +249,7 @@ void RequiredFieldsFallbackHandler::SetFallbackFieldValuesSequentially(
       // default: TAP
       click_type = ClickType::TAP;
     }
-    ActionDelegateUtil::ClickOrTapElement(
+    action_delegate_util::ClickOrTapElement(
         action_delegate_, required_field.selector, click_type,
         base::BindOnce(
             &RequiredFieldsFallbackHandler::OnClickOrTapFallbackElement,
@@ -374,7 +374,7 @@ void RequiredFieldsFallbackHandler::OnShortWaitForElement(
     // default: TAP
     click_type = ClickType::TAP;
   }
-  ActionDelegateUtil::ClickOrTapElement(
+  action_delegate_util::ClickOrTapElement(
       action_delegate_, selector_to_click, click_type,
       base::BindOnce(&RequiredFieldsFallbackHandler::OnSetFallbackFieldValue,
                      weak_ptr_factory_.GetWeakPtr(), required_fields_index,

components/autofill_assistant/browser/actions/focus_element_action.cc

@@ -72,14 +72,14 @@ void FocusElementAction::OnWaitForElement(ProcessActionCallback callback,
     return;
   }
 
-  auto actions = std::make_unique<ActionDelegateUtil::ElementActionVector>();
+  auto actions = std::make_unique<action_delegate_util::ElementActionVector>();
   actions->emplace_back(
       base::BindOnce(&ActionDelegate::WaitForDocumentToBecomeInteractive,
                      delegate_->GetWeakPtr()));
   actions->emplace_back(base::BindOnce(&ActionDelegate::FocusElement,
                                        delegate_->GetWeakPtr(), selector,
                                        top_padding));
-  ActionDelegateUtil::FindElementAndPerform(
+  action_delegate_util::FindElementAndPerformAll(
       delegate_, selector, std::move(actions),
       base::BindOnce(&FocusElementAction::OnFocusElement,
                      weak_ptr_factory_.GetWeakPtr(), std::move(callback)));

components/autofill_assistant/browser/actions/highlight_element_action.cc

@@ -48,7 +48,7 @@ void HighlightElementAction::OnWaitForElement(
     return;
   }
 
-  ActionDelegateUtil::FindElementAndPerform(
+  action_delegate_util::FindElementAndPerform(
       delegate_, selector,
       base::BindOnce(&ActionDelegate::HighlightElement,
                      delegate_->GetWeakPtr()),

components/autofill_assistant/browser/actions/select_option_action.cc

@@ -72,7 +72,7 @@ void SelectOptionAction::OnWaitForElement(const Selector& selector,
     return;
   }
 
-  ActionDelegateUtil::FindElementAndPerform(
+  action_delegate_util::FindElementAndPerform(
       delegate_, selector,
       base::BindOnce(&ActionDelegate::SelectOption, delegate_->GetWeakPtr(),
                      value_, proto_.select_option().select_strategy()),

components/autofill_assistant/browser/actions/set_attribute_action.cc

@@ -46,7 +46,7 @@ void SetAttributeAction::OnWaitForElement(ProcessActionCallback callback,
     return;
   }
 
-  ActionDelegateUtil::FindElementAndPerform(
+  action_delegate_util::FindElementAndPerform(
       delegate_, selector,
       base::BindOnce(&ActionDelegate::SetAttribute, delegate_->GetWeakPtr(),
                      ExtractVector(proto_.set_attribute().attribute()),

components/autofill_assistant/browser/actions/set_form_field_value_action.cc

@@ -186,7 +186,7 @@ void SetFormFieldValueAction::OnSetFieldValue(int next,
       /* next = */ next + 1);
   const auto& field_input = field_inputs_[next];
   if (field_input.keyboard_input) {
-    ActionDelegateUtil::SendKeyboardInput(
+    action_delegate_util::SendKeyboardInput(
         delegate_, selector_, *field_input.keyboard_input, delay_in_millisecond,
         std::move(next_field_callback));
   } else if (field_input.password_type != PasswordValueType::NOT_SET) {
@@ -205,11 +205,11 @@ void SetFormFieldValueAction::OnSetFieldValue(int next,
   } else {
     auto fill_strategy = proto_.set_form_value().fill_strategy();
     if (IsSimulatingKeyPresses(fill_strategy)) {
-      ActionDelegateUtil::SetFieldValue(delegate_, selector_, field_input.value,
-                                        fill_strategy, delay_in_millisecond,
-                                        std::move(next_field_callback));
+      action_delegate_util::SetFieldValue(
+          delegate_, selector_, field_input.value, fill_strategy,
+          delay_in_millisecond, std::move(next_field_callback));
     } else {
-      ActionDelegateUtil::SetFieldValue(
+      action_delegate_util::SetFieldValue(
           delegate_, selector_, field_input.value, fill_strategy,
           delay_in_millisecond,
           base::BindOnce(
@@ -256,7 +256,7 @@ void SetFormFieldValueAction::OnGetFieldValue(
 
     // Run |SetFieldValue| with keyboard simulation on and move on to next value
     // afterwards.
-    ActionDelegateUtil::SetFieldValue(
+    action_delegate_util::SetFieldValue(
         delegate_, selector_, requested_value, SIMULATE_KEY_PRESSES,
         proto_.set_form_value().delay_in_millisecond(),
         base::BindOnce(&SetFormFieldValueAction::OnSetFieldValue,
@@ -279,13 +279,13 @@ void SetFormFieldValueAction::OnGetStoredPassword(int field_index,
   auto fill_strategy = proto_.set_form_value().fill_strategy();
   int delay_in_millisecond = proto_.set_form_value().delay_in_millisecond();
   if (IsSimulatingKeyPresses(fill_strategy)) {
-    ActionDelegateUtil::SetFieldValue(
+    action_delegate_util::SetFieldValue(
         delegate_, selector_, password, fill_strategy, delay_in_millisecond,
         base::BindOnce(&SetFormFieldValueAction::OnSetFieldValue,
                        weak_ptr_factory_.GetWeakPtr(),
                        /* next = */ field_index + 1));
   } else {
-    ActionDelegateUtil::SetFieldValue(
+    action_delegate_util::SetFieldValue(
         delegate_, selector_, password, fill_strategy, delay_in_millisecond,
         base::BindOnce(
             &SetFormFieldValueAction::OnSetFieldValueAndCheckFallback,

components/autofill_assistant/browser/actions/upload_dom_action.cc

@@ -43,7 +43,7 @@ void UploadDomAction::OnWaitForElement(const Selector& selector,
     return;
   }
 
-  ActionDelegateUtil::FindElementAndGetProperty(
+  action_delegate_util::FindElementAndGetProperty(
       delegate_, selector,
       base::BindOnce(&ActionDelegate::GetOuterHtml, delegate_->GetWeakPtr()),
       base::BindOnce(&UploadDomAction::OnGetOuterHtml,

components/autofill_assistant/browser/script_executor.cc

@@ -1210,7 +1210,8 @@ void ScriptExecutor::WaitForDomOperation::RestorePreInterruptScroll() {
     return;
 
   if (!main_script_->last_focused_element_selector_.empty()) {
-    auto actions = std::make_unique<ActionDelegateUtil::ElementActionVector>();
+    auto actions =
+        std::make_unique<action_delegate_util::ElementActionVector>();
     actions->emplace_back(
         base::BindOnce(&ActionDelegate::WaitForDocumentToBecomeInteractive,
                        main_script_->GetWeakPtr()));
@@ -1218,7 +1219,7 @@ void ScriptExecutor::WaitForDomOperation::RestorePreInterruptScroll() {
         &ActionDelegate::FocusElement, main_script_->GetWeakPtr(),
         main_script_->last_focused_element_selector_,
         main_script_->last_focused_element_top_padding_));
-    ActionDelegateUtil::FindElementAndPerform(
+    action_delegate_util::FindElementAndPerformAll(
         main_script_, main_script_->last_focused_element_selector_,
         std::move(actions), base::DoNothing());
   }