autofill-try

components/autofill/content/browser/content_autofill_driver.cc

 // Copyright 2014 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/browser/content_autofill_driver.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "components/autofill/content/browser/content_autofill_driver_factory.h"
+#include "components/autofill/content/browser/autofill_provider.h"
 #include "components/autofill/core/browser/autofill_client.h"
 #include "components/autofill/core/browser/autofill_external_delegate.h"
 #include "components/autofill/core/browser/autofill_manager.h"
 #include "components/autofill/core/browser/form_structure.h"
 #include "components/autofill/core/common/autofill_switches.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "ui/gfx/geometry/size_f.h"
 
 namespace autofill {
 
 ContentAutofillDriver::ContentAutofillDriver(
     content::RenderFrameHost* render_frame_host,
     AutofillClient* client,
     const std::string& app_locale,
-    AutofillManager::AutofillDownloadManagerState enable_download_manager)
+    AutofillManager::AutofillDownloadManagerState enable_download_manager,
+    AutofillProvider* provider)
     : render_frame_host_(render_frame_host),
       client_(client),
       autofill_manager_(new AutofillManager(this,
                                             client,
                                             app_locale,
                                             enable_download_manager)),
       autofill_external_delegate_(autofill_manager_.get(), this),
-      binding_(this) {
+      binding_(this),
+      provider_(provider) {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   autofill_manager_->SetExternalDelegate(&autofill_external_delegate_);
 }
 
-ContentAutofillDriver::~ContentAutofillDriver() {}
+ContentAutofillDriver::~ContentAutofillDriver() {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
+  // Provider_ might already be distroyed, might use weak_ptr here.
+  if (provider_)
+    provider_->OnContentAutofillDriverDestroyed(this);
+}
 
 // static
 ContentAutofillDriver* ContentAutofillDriver::GetForRenderFrameHost(
     content::RenderFrameHost* render_frame_host) {
   ContentAutofillDriverFactory* factory =
       ContentAutofillDriverFactory::FromWebContents(
           content::WebContents::FromRenderFrameHost(render_frame_host));
   return factory ? factory->DriverForFrame(render_frame_host) : nullptr;
 }
 
 void ContentAutofillDriver::BindRequest(mojom::AutofillDriverRequest request) {
   binding_.Bind(std::move(request));
 }
 
 bool ContentAutofillDriver::IsOffTheRecord() const {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   return render_frame_host_->GetSiteInstance()
       ->GetBrowserContext()
       ->IsOffTheRecord();
 }
 
 net::URLRequestContextGetter* ContentAutofillDriver::GetURLRequestContext() {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   return content::BrowserContext::GetDefaultStoragePartition(
       render_frame_host_->GetSiteInstance()->GetBrowserContext())->
           GetURLRequestContext();
 }
 
 base::SequencedWorkerPool* ContentAutofillDriver::GetBlockingPool() {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   return content::BrowserThread::GetBlockingPool();
 }
 
 bool ContentAutofillDriver::RendererIsAvailable() {
   return render_frame_host_->GetRenderViewHost() != NULL;
 }
 
 void ContentAutofillDriver::SendFormDataToRenderer(
     int query_id,
     RendererFormDataAction action,
     const FormData& data) {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__ << this << "id = " << query_id;
+  LOG(ERROR) << "bt:" << data;
   if (!RendererIsAvailable())
     return;
 
   switch (action) {
     case FORM_DATA_ACTION_FILL:
       GetAutofillAgent()->FillForm(query_id, data);
       break;
     case FORM_DATA_ACTION_PREVIEW:
       GetAutofillAgent()->PreviewForm(query_id, data);
       break;
   }
 }
 
 void ContentAutofillDriver::PropagateAutofillPredictions(
     const std::vector<FormStructure*>& forms) {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   autofill_manager_->client()->PropagateAutofillPredictions(render_frame_host_,
                                                             forms);
 }
 
 void ContentAutofillDriver::SendAutofillTypePredictionsToRenderer(
     const std::vector<FormStructure*>& forms) {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kShowAutofillTypePredictions))
     return;
 
   if (!RendererIsAvailable())
     return;
 
   std::vector<FormDataPredictions> type_predictions =
       FormStructure::GetFieldTypePredictions(forms);
   GetAutofillAgent()->FieldTypePredictionsAvailable(type_predictions);
 }
 
 void ContentAutofillDriver::RendererShouldAcceptDataListSuggestion(
     const base::string16& value) {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   if (!RendererIsAvailable())
     return;
   GetAutofillAgent()->AcceptDataListSuggestion(value);
 }
 
 void ContentAutofillDriver::RendererShouldClearFilledForm() {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   if (!RendererIsAvailable())
     return;
   GetAutofillAgent()->ClearForm();
 }
 
 void ContentAutofillDriver::RendererShouldClearPreviewedForm() {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   if (!RendererIsAvailable())
     return;
   GetAutofillAgent()->ClearPreviewedForm();
 }
 
 void ContentAutofillDriver::RendererShouldFillFieldWithValue(
     const base::string16& value) {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   if (!RendererIsAvailable())
     return;
   GetAutofillAgent()->FillFieldWithValue(value);
 }
 
 void ContentAutofillDriver::RendererShouldPreviewFieldWithValue(
     const base::string16& value) {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   if (!RendererIsAvailable())
     return;
   GetAutofillAgent()->PreviewFieldWithValue(value);
 }
 
 void ContentAutofillDriver::PopupHidden() {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   // If the unmask prompt is showing, keep showing the preview. The preview
   // will be cleared when the prompt closes.
   if (!autofill_manager_->IsShowingUnmaskPrompt())
     RendererShouldClearPreviewedForm();
 }
 
 gfx::RectF ContentAutofillDriver::TransformBoundingBoxToViewportCoordinates(
     const gfx::RectF& bounding_box) {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   content::RenderWidgetHostView* view = render_frame_host_->GetView();
   if (!view)
     return bounding_box;
 
   gfx::Point orig_point(bounding_box.x(), bounding_box.y());
   gfx::Point transformed_point =
       view->TransformPointToRootCoordSpace(orig_point);
   return gfx::RectF(transformed_point.x(), transformed_point.y(),
                     bounding_box.width(), bounding_box.height());
 }
 
 void ContentAutofillDriver::DidInteractWithCreditCardForm() {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   // Notify the WebContents about credit card inputs on HTTP pages.
   content::WebContents* contents =
       content::WebContents::FromRenderFrameHost(render_frame_host_);
   if (contents->GetVisibleURL().SchemeIsCryptographic())
     return;
   contents->OnCreditCardInputShownOnHttp();
 }
 
 // mojom::AutofillDriver:
 void ContentAutofillDriver::FirstUserGestureObserved() {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   client_->OnFirstUserGestureObserved();
 }
 
 void ContentAutofillDriver::FormsSeen(const std::vector<FormData>& forms,
                                       base::TimeTicks timestamp) {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__ << forms.size();
+  for(auto form: forms) {
+    LOG(ERROR) << "bt:" << form;
+  }
   autofill_manager_->OnFormsSeen(forms, timestamp);
 }
 
 void ContentAutofillDriver::WillSubmitForm(const FormData& form,
                                            base::TimeTicks timestamp) {
-  autofill_manager_->OnWillSubmitForm(form, timestamp);
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
+  if (provider_)
+    provider_->OnWillSubmitForm(this, form, timestamp);
+  else
+    autofill_manager_->OnWillSubmitForm(form, timestamp);
 }
 
 void ContentAutofillDriver::FormSubmitted(const FormData& form) {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   autofill_manager_->OnFormSubmitted(form);
 }
 
 void ContentAutofillDriver::TextFieldDidChange(const FormData& form,
                                                const FormFieldData& field,
                                                base::TimeTicks timestamp) {
-  autofill_manager_->OnTextFieldDidChange(form, field, timestamp);
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
+  if (provider_)
+    provider_->OnTextFieldDidChange(this, form, field, timestamp);
+  else
+    autofill_manager_->OnTextFieldDidChange(form, field, timestamp);
 }
 
 void ContentAutofillDriver::QueryFormFieldAutofill(
     int32_t id,
     const FormData& form,
     const FormFieldData& field,
     const gfx::RectF& bounding_box) {
-  autofill_manager_->OnQueryFormFieldAutofill(id, form, field, bounding_box);
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__ << this << " id:" << id;
+  LOG(ERROR) << "bt:" << form;
+  LOG(ERROR) << "bt:" << field;
+  if (provider_)
+    provider_->OnQueryFormFieldAutofill(this, id, form, field, bounding_box);
+  else
+    autofill_manager_->OnQueryFormFieldAutofill(id, form, field, bounding_box);
 }
 
 void ContentAutofillDriver::HidePopup() {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   autofill_manager_->OnHidePopup();
 }
 
 void ContentAutofillDriver::FocusNoLongerOnForm() {
-  autofill_manager_->OnFocusNoLongerOnForm();
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
+  if (provider_)
+    provider_->OnFocusNoLongerOnForm(this);
+  else
+    autofill_manager_->OnFocusNoLongerOnForm();
 }
 
 void ContentAutofillDriver::DidFillAutofillFormData(const FormData& form,
                                                     base::TimeTicks timestamp) {
-  autofill_manager_->OnDidFillAutofillFormData(form, timestamp);
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
+  if (provider_)
+    provider_->OnDidFillAutofillFormData(this, form, timestamp);
+  else
+    autofill_manager_->OnDidFillAutofillFormData(form, timestamp);
 }
 
 void ContentAutofillDriver::DidPreviewAutofillFormData() {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   autofill_manager_->OnDidPreviewAutofillFormData();
 }
 
 void ContentAutofillDriver::DidEndTextFieldEditing() {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   autofill_manager_->OnDidEndTextFieldEditing();
 }
 
 void ContentAutofillDriver::SetDataList(
     const std::vector<base::string16>& values,
     const std::vector<base::string16>& labels) {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
+  for(auto v : values) {
+    LOG(ERROR) << "bt:" << v;
+  }
+  for(auto l : labels) {
+    LOG(ERROR) << "bt:" << l;
+  }
+
   autofill_manager_->OnSetDataList(values, labels);
 }
 
 void ContentAutofillDriver::DidNavigateFrame(
     content::NavigationHandle* navigation_handle) {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   if (navigation_handle->IsInMainFrame() &&
       !navigation_handle->IsSameDocument()) {
     autofill_manager_->Reset();
   }
 }
 
 void ContentAutofillDriver::SetAutofillManager(
     std::unique_ptr<AutofillManager> manager) {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   autofill_manager_ = std::move(manager);
   autofill_manager_->SetExternalDelegate(&autofill_external_delegate_);
 }
 
 void ContentAutofillDriver::NotifyFirstUserGestureObservedInTab() {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   GetAutofillAgent()->FirstUserGestureObservedInTab();
 }
 
 const mojom::AutofillAgentPtr& ContentAutofillDriver::GetAutofillAgent() {
+  LOG(ERROR) << "bt:" << __PRETTY_FUNCTION__;
   // Here is a lazy binding, and will not reconnect after connection error.
   if (!autofill_agent_) {
     render_frame_host_->GetRemoteInterfaces()->GetInterface(
         mojo::MakeRequest(&autofill_agent_));
   }
 
   return autofill_agent_;
 }
 
 }  // namespace autofill