[Autofill Assistant] Lazy instantiate web controller, service, memory and script tracker

Instantiate these instances when needed since the flow can be short,
especially when the intent is from Chrome, like abort on onboard screen
or failed to get scripts or do not accept the script.

Bug: 806868
Change-Id: Ib72e90a72bd8539376e54ec0a6615a14bade0568
Reviewed-on: https://chromium-review.googlesource.com/c/1430520
Commit-Queue: Ganggui Tang <gogerald@chromium.org>
Auto-Submit: Ganggui Tang <gogerald@chromium.org>
Reviewed-by: Stephane Zermatten <szermatt@chromium.org>
Cr-Commit-Position: refs/heads/master@{#626144}

chrome/browser/android/autofill_assistant/client_android.cc

@@ -226,11 +226,7 @@ void ClientAndroid::CreateController() {
   if (controller_) {
     return;
   }
-  controller_ = std::make_unique<Controller>(
-      web_contents_,
-      /* client= */ this, WebController::CreateForWebContents(web_contents_),
-      Service::Create(web_contents_->GetBrowserContext(),
-                      /* client= */ this));
+  controller_ = std::make_unique<Controller>(web_contents_, /* client= */ this);
 }
 
 WEB_CONTENTS_USER_DATA_KEY_IMPL(ClientAndroid);

components/autofill_assistant/browser/controller.h

@@ -43,10 +43,7 @@ class Controller : public ScriptExecutorDelegate,
  public:
   // |web_contents| and |client| must remain valid for the lifetime of the
   // instance.
-  Controller(content::WebContents* web_contents,
-             Client* client,
-             std::unique_ptr<WebController> web_controller,
-             std::unique_ptr<Service> service);
+  Controller(content::WebContents* web_contents, Client* client);
   ~Controller() override;
 
   // Called when autofill assistant can start executing scripts.
@@ -87,6 +84,10 @@ class Controller : public ScriptExecutorDelegate,
  private:
   friend ControllerTest;
 
+  void SetWebControllerAndServiceForTest(
+      std::unique_ptr<WebController> web_controller,
+      std::unique_ptr<Service> service);
+
   void GetOrCheckScripts(const GURL& url);
   void OnGetScripts(const GURL& url, bool result, const std::string& response);
   void ExecuteScript(const std::string& script_path);
@@ -146,10 +147,19 @@ class Controller : public ScriptExecutorDelegate,
   void LoadProgressChanged(content::WebContents* source,
                            double progress) override;
 
+  ElementArea* touchable_element_area();
+  ScriptTracker* script_tracker();
+
   Client* const client_;
+
+  // Lazily instantiate in GetWebController().
   std::unique_ptr<WebController> web_controller_;
+
+  // Lazily instantiate in GetService().
   std::unique_ptr<Service> service_;
   std::map<std::string, std::string> parameters_;
+
+  // Lazily instantiate in GetClientMemory().
   std::unique_ptr<ClientMemory> memory_;
 
   AutofillAssistantState state_ = AutofillAssistantState::INACTIVE;
@@ -175,7 +185,8 @@ class Controller : public ScriptExecutorDelegate,
 
   // Area of the screen that corresponds to the current set of touchable
   // elements.
-  ElementArea touchable_element_area_;
+  // Lazily instantiate in touchable_element_area().
+  std::unique_ptr<ElementArea> touchable_element_area_;
 
   // Current status message, may be empty.
   std::string status_message_;
@@ -189,6 +200,7 @@ class Controller : public ScriptExecutorDelegate,
   // Tracks scripts and script execution. It's kept at the end, as it tend to
   // depend on everything the controller support, through script and script
   // actions.
+  // Lazily instantiate in script_tracker().
   std::unique_ptr<ScriptTracker> script_tracker_;
 
   base::WeakPtrFactory<Controller> weak_ptr_factory_;

components/autofill_assistant/browser/controller_unittest.cc

@@ -76,9 +76,9 @@ class ControllerTest : public content::RenderViewHostTestHarness {
     auto service = std::make_unique<NiceMock<MockService>>();
     mock_service_ = service.get();
 
-    controller_ = std::make_unique<Controller>(web_contents(), &fake_client_,
-                                               std::move(web_controller),
-                                               std::move(service));
+    controller_ = std::make_unique<Controller>(web_contents(), &fake_client_);
+    controller_->SetWebControllerAndServiceForTest(std::move(web_controller),
+                                                   std::move(service));
 
     // Fetching scripts succeeds for all URLs, but return nothing.
     ON_CALL(*mock_service_, OnGetScriptsForUrl(_, _, _))

components/autofill_assistant/browser/element_area.cc

@@ -11,6 +11,7 @@
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#include "components/autofill_assistant/browser/script_executor_delegate.h"
 #include "components/autofill_assistant/browser/web_controller.h"
 
 namespace autofill_assistant {
@@ -21,11 +22,9 @@ static constexpr base::TimeDelta kCheckDelay =
     base::TimeDelta::FromMilliseconds(100);
 }  // namespace
 
-ElementArea::ElementArea(WebController* web_controller)
-    : web_controller_(web_controller),
-      scheduled_update_(false),
-      weak_ptr_factory_(this) {
-  DCHECK(web_controller_);
+ElementArea::ElementArea(ScriptExecutorDelegate* delegate)
+    : delegate_(delegate), scheduled_update_(false), weak_ptr_factory_(this) {
+  DCHECK(delegate_);
 }
 
 ElementArea::~ElementArea() = default;
@@ -82,7 +81,7 @@ void ElementArea::UpdatePositions() {
       position.pending_update = true;
     }
     for (auto& position : rectangle.positions) {
-      web_controller_->GetElementPosition(
+      delegate_->GetWebController()->GetElementPosition(
           position.selector,
           base::BindOnce(&ElementArea::OnGetElementPosition,
                          weak_ptr_factory_.GetWeakPtr(), position.selector));

components/autofill_assistant/browser/element_area.h

@@ -15,14 +15,14 @@
 #include "components/autofill_assistant/browser/selector.h"
 
 namespace autofill_assistant {
-class WebController;
+class ScriptExecutorDelegate;
 
 // A helper that keeps track of the area on the screen that correspond to an
 // changeable set of elements.
 class ElementArea {
  public:
-  // |web_controller| must remain valid for the lifetime of this instance.
-  explicit ElementArea(WebController* web_controller);
+  // |delegate| must remain valid for the lifetime of this instance.
+  explicit ElementArea(ScriptExecutorDelegate* delegate);
   ~ElementArea();
 
   // Clears the area. Stops scheduled updates.
@@ -107,7 +107,7 @@ class ElementArea {
                             const RectF& rect);
   void ReportUpdate();
 
-  WebController* const web_controller_;
+  ScriptExecutorDelegate* const delegate_;
   std::vector<Rectangle> rectangles_;
   bool cover_viewport_ = false;
 

components/autofill_assistant/browser/element_area_unittest.cc

@@ -5,6 +5,7 @@
 #include "components/autofill_assistant/browser/element_area.h"
 
 #include <algorithm>
+#include <map>
 
 #include "base/bind.h"
 #include "base/strings/stringprintf.h"
@@ -12,6 +13,7 @@
 #include "base/test/scoped_task_environment.h"
 #include "components/autofill_assistant/browser/mock_run_once_callback.h"
 #include "components/autofill_assistant/browser/mock_web_controller.h"
+#include "components/autofill_assistant/browser/script_executor_delegate.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::_;
@@ -39,18 +41,48 @@ MATCHER_P4(MatchingRectF,
 
 ACTION(DoNothing) {}
 
-class ElementAreaTest : public testing::Test {
+class ElementAreaTest : public testing::Test, public ScriptExecutorDelegate {
  protected:
   ElementAreaTest()
       : scoped_task_environment_(
             base::test::ScopedTaskEnvironment::MainThreadType::MOCK_TIME),
-        element_area_(&mock_web_controller_) {
+        element_area_(this) {
     ON_CALL(mock_web_controller_, OnGetElementPosition(_, _))
         .WillByDefault(RunOnceCallback<1>(false, RectF()));
     element_area_.SetOnUpdate(base::BindRepeating(&ElementAreaTest::OnUpdate,
                                                   base::Unretained(this)));
   }
 
+  // Overrides ScriptTrackerDelegate
+  Service* GetService() override { return nullptr; }
+
+  UiController* GetUiController() override { return nullptr; }
+
+  WebController* GetWebController() override { return &mock_web_controller_; }
+
+  ClientMemory* GetClientMemory() override { return nullptr; }
+
+  void EnterState(AutofillAssistantState state) override {}
+
+  const std::map<std::string, std::string>& GetParameters() override {
+    return parameters_;
+  }
+
+  autofill::PersonalDataManager* GetPersonalDataManager() override {
+    return nullptr;
+  }
+
+  content::WebContents* GetWebContents() override { return nullptr; }
+
+  void SetTouchableElementArea(const ElementAreaProto& element_area) override {}
+
+  void SetStatusMessage(const std::string& status_message) override {}
+  std::string GetStatusMessage() const override { return std::string(); }
+
+  void SetDetails(const Details& details) override {}
+
+  void ClearDetails() override {}
+
   void SetElement(const std::string& selector) {
     ElementAreaProto area;
     area.add_rectangles()->add_elements()->add_selectors(selector);
@@ -66,6 +98,7 @@ class ElementAreaTest : public testing::Test {
   base::test::ScopedTaskEnvironment scoped_task_environment_;
 
   MockWebController mock_web_controller_;
+  std::map<std::string, std::string> parameters_;
   ElementArea element_area_;
   std::vector<RectF> highlighted_area_;
 };