chrome/browser/cart/commerce_hint_service.cc - chromium/src - Git at Google

 // Copyright 2021 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 "chrome/browser/cart/commerce_hint_service.h"

 #include <map>
 #include <memory>

 #include "base/metrics/histogram_functions.h"
 #include "base/time/time.h"
 #include "chrome/browser/cart/cart_db_content.pb.h"
 #include "chrome/browser/cart/cart_features.h"
 #include "chrome/browser/cart/cart_service.h"
 #include "chrome/browser/cart/cart_service_factory.h"
 #include "chrome/browser/optimization_guide/optimization_guide_keyed_service.h"
 #include "chrome/browser/optimization_guide/optimization_guide_keyed_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/search/ntp_features.h"
 #include "components/ukm/content/source_url_recorder.h"
 #include "content/public/browser/document_service.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_user_data.h"
 #include "crypto/random.h"
 #include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "services/metrics/public/cpp/ukm_builders.h"
 #include "services/metrics/public/cpp/ukm_recorder.h"

 namespace cart {

 namespace {
 // TODO(crbug/1164236): support multiple cart systems in the same domain.
 // Returns eTLB+1 domain.
 std::string GetDomain(const GURL& url) {
   return net::registry_controlled_domains::GetDomainAndRegistry(
       url, net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
 }

 void ConstructCartProto(cart_db::ChromeCartContentProto* proto,
                         const GURL& navigation_url,
                         std::vector<mojom::ProductPtr> products) {
   const std::string& domain = GetDomain(navigation_url);
   proto->set_key(domain);
   proto->set_merchant(domain);
   proto->set_merchant_cart_url(navigation_url.spec());
   proto->set_timestamp(base::Time::Now().ToDoubleT());
   for (auto& product : products) {
     if (product->image_url.spec().size() != 0) {
       proto->add_product_image_urls(product->image_url.spec());
     }
     if (!product->product_id.empty()) {
       cart_db::ChromeCartProductProto product_proto;
       product_proto.set_product_id(std::move(product->product_id));
       cart_db::ChromeCartProductProto* added_product =
           proto->add_product_infos();
       *added_product = std::move(product_proto);
     }
   }
 }

 }  // namespace

 // Implementation of the Mojo CommerceHintObserver. This is called by the
 // renderer to notify the browser that a commerce hint happens.
 class CommerceHintObserverImpl
     : public content::DocumentService<mojom::CommerceHintObserver> {
  public:
   explicit CommerceHintObserverImpl(
       content::RenderFrameHost* render_frame_host,
       mojo::PendingReceiver<mojom::CommerceHintObserver> receiver,
       base::WeakPtr<CommerceHintService> service)
       : DocumentService(render_frame_host, std::move(receiver)),
         binding_url_(render_frame_host->GetLastCommittedURL()),
         service_(std::move(service)) {}

   ~CommerceHintObserverImpl() override = default;

   void OnAddToCart(const absl::optional<GURL>& cart_url,
                    const std::string& product_id) override {
     DVLOG(1) << "Received OnAddToCart in the browser process on "
              << binding_url_;
     if (!service_ || !binding_url_.SchemeIsHTTPOrHTTPS())
       return;
     service_->OnAddToCart(binding_url_, cart_url, product_id);
   }

   void OnVisitCart() override {
     DVLOG(1) << "Received OnVisitCart in the browser process";
     if (!service_ || !binding_url_.SchemeIsHTTPOrHTTPS())
       return;
     service_->OnAddToCart(binding_url_, binding_url_);
   }

   void OnCartProductUpdated(std::vector<mojom::ProductPtr> products) override {
     DVLOG(1) << "Received OnCartProductUpdated in the browser process, with "
              << products.size() << " product(s).";
     if (!service_ || !binding_url_.SchemeIsHTTPOrHTTPS())
       return;

     if (products.empty()) {
       service_->OnRemoveCart(binding_url_);
     } else {
       service_->OnCartUpdated(binding_url_, std::move(products));
     }
   }

   void OnVisitCheckout() override {
     DVLOG(1) << "Received OnVisitCheckout in the browser process";
     if (!service_ || !binding_url_.SchemeIsHTTPOrHTTPS())
       return;
     service_->OnRemoveCart(binding_url_);
   }

   void OnPurchase() override {
     DVLOG(1) << "Received OnPurchase in the browser process";
     if (!service_ || !binding_url_.SchemeIsHTTPOrHTTPS())
       return;
     service_->OnRemoveCart(binding_url_);
   }

   void OnFormSubmit(bool is_purchase) override {
     DVLOG(1) << "Received OnFormSubmit in the browser process";
     if (!service_ || !binding_url_.SchemeIsHTTPOrHTTPS())
       return;
     service_->OnFormSubmit(binding_url_, is_purchase);
   }

   void OnWillSendRequest(bool is_addtocart) override {
     DVLOG(1) << "Received OnWillSendRequest in the browser process";
     if (!service_ || !binding_url_.SchemeIsHTTPOrHTTPS())
       return;
     service_->OnWillSendRequest(binding_url_, is_addtocart);
   }

  private:
   GURL binding_url_;
   base::WeakPtr<CommerceHintService> service_;
 };

 CommerceHintService::CommerceHintService(content::WebContents* web_contents)
     : web_contents_(web_contents) {
   DCHECK(!web_contents->GetBrowserContext()->IsOffTheRecord());
   Profile* profile =
       Profile::FromBrowserContext(web_contents_->GetBrowserContext());
   service_ = CartServiceFactory::GetInstance()->GetForProfile(profile);
   optimization_guide_decider_ =
       OptimizationGuideKeyedServiceFactory::GetForProfile(profile);
   if (optimization_guide_decider_) {
     optimization_guide_decider_->RegisterOptimizationTypes(
         {optimization_guide::proto::SHOPPING_PAGE_PREDICTOR});
   }
 }

 CommerceHintService::~CommerceHintService() = default;

 content::WebContents* CommerceHintService::WebContents() {
   return web_contents_;
 }

 void CommerceHintService::BindCommerceHintObserver(
     content::RenderFrameHost* host,
     mojo::PendingReceiver<mojom::CommerceHintObserver> receiver) {
   // The object is bound to the lifetime of |host| and the mojo
   // connection. See DocumentService for details.
   new CommerceHintObserverImpl(host, std::move(receiver),
                                weak_factory_.GetWeakPtr());
 }

 bool CommerceHintService::ShouldSkip(const GURL& url) {
   if (!optimization_guide_decider_) {
     return false;
   }

   optimization_guide::OptimizationMetadata metadata;
   auto decision = optimization_guide_decider_->CanApplyOptimization(
       url, optimization_guide::proto::SHOPPING_PAGE_PREDICTOR, &metadata);
   DVLOG(1) << "SHOPPING_PAGE_PREDICTOR = " << static_cast<int>(decision);
   return optimization_guide::OptimizationGuideDecision::kFalse == decision;
 }

 void CommerceHintService::OnAddToCart(const GURL& navigation_url,
                                       const absl::optional<GURL>& cart_url,
                                       const std::string& product_id) {
   if (ShouldSkip(navigation_url))
     return;
   absl::optional<GURL> validated_cart = cart_url;
   if (cart_url && GetDomain(*cart_url) != GetDomain(navigation_url)) {
     DVLOG(1) << "Reject cart URL with different eTLD+1 domain.";
     validated_cart = absl::nullopt;
   }
   // When rule-based discount is enabled, do not accept cart page URLs from
   // partner merchants as there could be things like discount tokens in them.
   if (service_->IsCartDiscountEnabled() &&
       cart_features::IsRuleDiscountPartnerMerchant(navigation_url) &&
       product_id.empty()) {
     validated_cart = absl::nullopt;
   }
   cart_db::ChromeCartContentProto proto;
   std::vector<mojom::ProductPtr> products;
   if (!product_id.empty()) {
     mojom::ProductPtr product_ptr(mojom::Product::New());
     product_ptr->product_id = product_id;
     products.push_back(std::move(product_ptr));
   }
   ConstructCartProto(&proto, navigation_url, std::move(products));
   service_->AddCart(GetDomain(navigation_url), validated_cart,
                     std::move(proto));
 }

 void CommerceHintService::OnRemoveCart(const GURL& url) {
   service_->DeleteCart(GetDomain(url), false);
 }

 void CommerceHintService::OnCartUpdated(
     const GURL& cart_url,
     std::vector<mojom::ProductPtr> products) {
   if (ShouldSkip(cart_url))
     return;
   absl::optional<GURL> validated_cart = cart_url;
   // When rule-based discount is enabled, do not accept cart page URLs from
   // partner merchants as there could be things like discount tokens in them.
   if (service_->IsCartDiscountEnabled() &&
       cart_features::IsRuleDiscountPartnerMerchant(cart_url)) {
     validated_cart = absl::nullopt;
   }
   cart_db::ChromeCartContentProto proto;
   ConstructCartProto(&proto, cart_url, std::move(products));
   service_->AddCart(proto.key(), validated_cart, std::move(proto));
 }

 void CommerceHintService::OnFormSubmit(const GURL& navigation_url,
                                        bool is_purchase) {
   if (ShouldSkip(navigation_url))
     return;
   uint8_t bytes[1];
   crypto::RandBytes(bytes);
   bool report_truth = bytes[0] & 0x1;
   bool random = (bytes[0] >> 1) & 0x1;
   bool reported = report_truth ? is_purchase : random;
   ukm::builders::Shopping_FormSubmitted(
       ukm::GetSourceIdForWebContentsDocument(web_contents_))
       .SetIsTransaction(reported)
       .Record(ukm::UkmRecorder::Get());
   base::UmaHistogramBoolean("Commerce.Carts.FormSubmitIsTransaction", reported);
 }

 void CommerceHintService::OnWillSendRequest(const GURL& navigation_url,
                                             bool is_addtocart) {
   if (ShouldSkip(navigation_url))
     return;
   uint8_t bytes[1];
   crypto::RandBytes(bytes);
   bool report_truth = bytes[0] & 0x1;
   bool random = (bytes[0] >> 1) & 0x1;
   bool reported = report_truth ? is_addtocart : random;
   ukm::builders::Shopping_WillSendRequest(
       ukm::GetSourceIdForWebContentsDocument(web_contents_))
       .SetIsAddToCart(reported)
       .Record(ukm::UkmRecorder::Get());
   base::UmaHistogramBoolean("Commerce.Carts.XHRIsAddToCart", reported);
 }

 WEB_CONTENTS_USER_DATA_KEY_IMPL(CommerceHintService);

 }  // namespace cart
	// Copyright 2021 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 "chrome/browser/cart/commerce_hint_service.h"

	#include <map>
	#include <memory>

	#include "base/metrics/histogram_functions.h"
	#include "base/time/time.h"
	#include "chrome/browser/cart/cart_db_content.pb.h"
	#include "chrome/browser/cart/cart_features.h"
	#include "chrome/browser/cart/cart_service.h"
	#include "chrome/browser/cart/cart_service_factory.h"
	#include "chrome/browser/optimization_guide/optimization_guide_keyed_service.h"
	#include "chrome/browser/optimization_guide/optimization_guide_keyed_service_factory.h"
	#include "chrome/browser/profiles/profile.h"
	#include "components/search/ntp_features.h"
	#include "components/ukm/content/source_url_recorder.h"
	#include "content/public/browser/document_service.h"
	#include "content/public/browser/web_contents.h"
	#include "content/public/browser/web_contents_user_data.h"
	#include "crypto/random.h"
	#include "mojo/public/cpp/bindings/self_owned_receiver.h"
	#include "net/base/registry_controlled_domains/registry_controlled_domain.h"
	#include "services/metrics/public/cpp/ukm_builders.h"
	#include "services/metrics/public/cpp/ukm_recorder.h"

	namespace cart {

	namespace {
	// TODO(crbug/1164236): support multiple cart systems in the same domain.
	// Returns eTLB+1 domain.
	std::string GetDomain(const GURL& url) {
	return net::registry_controlled_domains::GetDomainAndRegistry(
	url, net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
	}

	void ConstructCartProto(cart_db::ChromeCartContentProto* proto,
	const GURL& navigation_url,
	std::vector<mojom::ProductPtr> products) {
	const std::string& domain = GetDomain(navigation_url);
	proto->set_key(domain);
	proto->set_merchant(domain);
	proto->set_merchant_cart_url(navigation_url.spec());
	proto->set_timestamp(base::Time::Now().ToDoubleT());
	for (auto& product : products) {
	if (product->image_url.spec().size() != 0) {
	proto->add_product_image_urls(product->image_url.spec());
	}
	if (!product->product_id.empty()) {
	cart_db::ChromeCartProductProto product_proto;
	product_proto.set_product_id(std::move(product->product_id));
	cart_db::ChromeCartProductProto* added_product =
	proto->add_product_infos();
	*added_product = std::move(product_proto);
	}
	}
	}

	} // namespace

	// Implementation of the Mojo CommerceHintObserver. This is called by the
	// renderer to notify the browser that a commerce hint happens.
	class CommerceHintObserverImpl
	: public content::DocumentService<mojom::CommerceHintObserver> {
	public:
	explicit CommerceHintObserverImpl(
	content::RenderFrameHost* render_frame_host,
	mojo::PendingReceiver<mojom::CommerceHintObserver> receiver,
	base::WeakPtr<CommerceHintService> service)
	: DocumentService(render_frame_host, std::move(receiver)),
	binding_url_(render_frame_host->GetLastCommittedURL()),
	service_(std::move(service)) {}

	~CommerceHintObserverImpl() override = default;

	void OnAddToCart(const absl::optional<GURL>& cart_url,
	const std::string& product_id) override {
	DVLOG(1) << "Received OnAddToCart in the browser process on "
	<< binding_url_;
	if (!service_ \|\| !binding_url_.SchemeIsHTTPOrHTTPS())
	return;
	service_->OnAddToCart(binding_url_, cart_url, product_id);
	}

	void OnVisitCart() override {
	DVLOG(1) << "Received OnVisitCart in the browser process";
	if (!service_ \|\| !binding_url_.SchemeIsHTTPOrHTTPS())
	return;
	service_->OnAddToCart(binding_url_, binding_url_);
	}

	void OnCartProductUpdated(std::vector<mojom::ProductPtr> products) override {
	DVLOG(1) << "Received OnCartProductUpdated in the browser process, with "
	<< products.size() << " product(s).";
	if (!service_ \|\| !binding_url_.SchemeIsHTTPOrHTTPS())
	return;

	if (products.empty()) {
	service_->OnRemoveCart(binding_url_);
	} else {
	service_->OnCartUpdated(binding_url_, std::move(products));
	}
	}

	void OnVisitCheckout() override {
	DVLOG(1) << "Received OnVisitCheckout in the browser process";
	if (!service_ \|\| !binding_url_.SchemeIsHTTPOrHTTPS())
	return;
	service_->OnRemoveCart(binding_url_);
	}

	void OnPurchase() override {
	DVLOG(1) << "Received OnPurchase in the browser process";
	if (!service_ \|\| !binding_url_.SchemeIsHTTPOrHTTPS())
	return;
	service_->OnRemoveCart(binding_url_);
	}

	void OnFormSubmit(bool is_purchase) override {
	DVLOG(1) << "Received OnFormSubmit in the browser process";
	if (!service_ \|\| !binding_url_.SchemeIsHTTPOrHTTPS())
	return;
	service_->OnFormSubmit(binding_url_, is_purchase);
	}

	void OnWillSendRequest(bool is_addtocart) override {
	DVLOG(1) << "Received OnWillSendRequest in the browser process";
	if (!service_ \|\| !binding_url_.SchemeIsHTTPOrHTTPS())
	return;
	service_->OnWillSendRequest(binding_url_, is_addtocart);
	}

	private:
	GURL binding_url_;
	base::WeakPtr<CommerceHintService> service_;
	};

	CommerceHintService::CommerceHintService(content::WebContents* web_contents)
	: web_contents_(web_contents) {
	DCHECK(!web_contents->GetBrowserContext()->IsOffTheRecord());
	Profile* profile =
	Profile::FromBrowserContext(web_contents_->GetBrowserContext());
	service_ = CartServiceFactory::GetInstance()->GetForProfile(profile);
	optimization_guide_decider_ =
	OptimizationGuideKeyedServiceFactory::GetForProfile(profile);
	if (optimization_guide_decider_) {
	optimization_guide_decider_->RegisterOptimizationTypes(
	{optimization_guide::proto::SHOPPING_PAGE_PREDICTOR});
	}
	}

	CommerceHintService::~CommerceHintService() = default;

	content::WebContents* CommerceHintService::WebContents() {
	return web_contents_;
	}

	void CommerceHintService::BindCommerceHintObserver(
	content::RenderFrameHost* host,
	mojo::PendingReceiver<mojom::CommerceHintObserver> receiver) {
	// The object is bound to the lifetime of \|host\| and the mojo
	// connection. See DocumentService for details.
	new CommerceHintObserverImpl(host, std::move(receiver),
	weak_factory_.GetWeakPtr());
	}

	bool CommerceHintService::ShouldSkip(const GURL& url) {
	if (!optimization_guide_decider_) {
	return false;
	}

	optimization_guide::OptimizationMetadata metadata;
	auto decision = optimization_guide_decider_->CanApplyOptimization(
	url, optimization_guide::proto::SHOPPING_PAGE_PREDICTOR, &metadata);
	DVLOG(1) << "SHOPPING_PAGE_PREDICTOR = " << static_cast<int>(decision);
	return optimization_guide::OptimizationGuideDecision::kFalse == decision;
	}

	void CommerceHintService::OnAddToCart(const GURL& navigation_url,
	const absl::optional<GURL>& cart_url,
	const std::string& product_id) {
	if (ShouldSkip(navigation_url))
	return;
	absl::optional<GURL> validated_cart = cart_url;
	if (cart_url && GetDomain(*cart_url) != GetDomain(navigation_url)) {
	DVLOG(1) << "Reject cart URL with different eTLD+1 domain.";
	validated_cart = absl::nullopt;
	}
	// When rule-based discount is enabled, do not accept cart page URLs from
	// partner merchants as there could be things like discount tokens in them.
	if (service_->IsCartDiscountEnabled() &&
	cart_features::IsRuleDiscountPartnerMerchant(navigation_url) &&
	product_id.empty()) {
	validated_cart = absl::nullopt;
	}
	cart_db::ChromeCartContentProto proto;
	std::vector<mojom::ProductPtr> products;
	if (!product_id.empty()) {
	mojom::ProductPtr product_ptr(mojom::Product::New());
	product_ptr->product_id = product_id;
	products.push_back(std::move(product_ptr));
	}
	ConstructCartProto(&proto, navigation_url, std::move(products));
	service_->AddCart(GetDomain(navigation_url), validated_cart,
	std::move(proto));
	}

	void CommerceHintService::OnRemoveCart(const GURL& url) {
	service_->DeleteCart(GetDomain(url), false);
	}

	void CommerceHintService::OnCartUpdated(
	const GURL& cart_url,
	std::vector<mojom::ProductPtr> products) {
	if (ShouldSkip(cart_url))
	return;
	absl::optional<GURL> validated_cart = cart_url;
	// When rule-based discount is enabled, do not accept cart page URLs from
	// partner merchants as there could be things like discount tokens in them.
	if (service_->IsCartDiscountEnabled() &&
	cart_features::IsRuleDiscountPartnerMerchant(cart_url)) {
	validated_cart = absl::nullopt;
	}
	cart_db::ChromeCartContentProto proto;
	ConstructCartProto(&proto, cart_url, std::move(products));
	service_->AddCart(proto.key(), validated_cart, std::move(proto));
	}

	void CommerceHintService::OnFormSubmit(const GURL& navigation_url,
	bool is_purchase) {
	if (ShouldSkip(navigation_url))
	return;
	uint8_t bytes[1];
	crypto::RandBytes(bytes);
	bool report_truth = bytes[0] & 0x1;
	bool random = (bytes[0] >> 1) & 0x1;
	bool reported = report_truth ? is_purchase : random;
	ukm::builders::Shopping_FormSubmitted(
	ukm::GetSourceIdForWebContentsDocument(web_contents_))
	.SetIsTransaction(reported)
	.Record(ukm::UkmRecorder::Get());
	base::UmaHistogramBoolean("Commerce.Carts.FormSubmitIsTransaction", reported);
	}

	void CommerceHintService::OnWillSendRequest(const GURL& navigation_url,
	bool is_addtocart) {
	if (ShouldSkip(navigation_url))
	return;
	uint8_t bytes[1];
	crypto::RandBytes(bytes);
	bool report_truth = bytes[0] & 0x1;
	bool random = (bytes[0] >> 1) & 0x1;
	bool reported = report_truth ? is_addtocart : random;
	ukm::builders::Shopping_WillSendRequest(
	ukm::GetSourceIdForWebContentsDocument(web_contents_))
	.SetIsAddToCart(reported)
	.Record(ukm::UkmRecorder::Get());
	base::UmaHistogramBoolean("Commerce.Carts.XHRIsAddToCart", reported);
	}

	WEB_CONTENTS_USER_DATA_KEY_IMPL(CommerceHintService);

	} // namespace cart