| // Copyright 2017 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "components/omnibox/browser/remote_suggestions_service.h" |
| |
| #include <map> |
| #include <memory> |
| #include <optional> |
| #include <string> |
| #include <utility> |
| |
| #include "base/functional/bind.h" |
| #include "base/metrics/histogram_functions.h" |
| #include "base/strings/stringprintf.h" |
| #include "base/time/time.h" |
| #include "base/timer/elapsed_timer.h" |
| #include "components/lens/proto/server/lens_overlay_response.pb.h" |
| #include "components/omnibox/browser/base_search_provider.h" |
| #include "components/omnibox/browser/document_suggestions_service.h" |
| #include "components/omnibox/browser/enterprise_search_aggregator_suggestions_service.h" |
| #include "components/search/search.h" |
| #include "components/search_engines/template_url_service.h" |
| #include "components/variations/net/variations_http_headers.h" |
| #include "net/base/load_flags.h" |
| #include "net/base/url_util.h" |
| #include "net/traffic_annotation/network_traffic_annotation.h" |
| #include "services/network/public/cpp/resource_request.h" |
| #include "services/network/public/cpp/shared_url_loader_factory.h" |
| #include "services/network/public/cpp/simple_url_loader.h" |
| #include "services/network/public/mojom/url_response_head.mojom.h" |
| #include "third_party/metrics_proto/omnibox_event.pb.h" |
| |
| namespace { |
| |
| std::string RequestTypeToString(RemoteRequestType request_type) { |
| switch (request_type) { |
| case RemoteRequestType::kSearch: |
| return "Search"; |
| case RemoteRequestType::kSearchWarmup: |
| return "SearchWarmup"; |
| case RemoteRequestType::kImages: |
| return "Images"; |
| case RemoteRequestType::kZeroSuggest: |
| return "ZeroSuggest"; |
| case RemoteRequestType::kZeroSuggestPrefetch: |
| return "ZeroSuggestPrefetch"; |
| case RemoteRequestType::kDocumentSuggest: |
| return "DocumentSuggest"; |
| case RemoteRequestType::kDeletion: |
| return "Deletion"; |
| case RemoteRequestType::kEnterpriseSearchAggregatorSuggest: |
| return "EnterpriseSearchAggregatorSuggest"; |
| } |
| } |
| |
| std::string ResponseCodeToSuccessString(int response_code) { |
| return response_code == 200 ? "Successful" : "Failed"; |
| } |
| |
| void LogRequestSent( |
| RemoteRequestType request_type, |
| metrics::OmniboxEventProto::PageClassification page_classification) { |
| base::UmaHistogramEnumeration("Omnibox.SuggestRequestsSent", request_type); |
| |
| // Don't slice by page classification for invalid page classifications. |
| if (page_classification == metrics::OmniboxEventProto::INVALID_SPEC) { |
| return; |
| } |
| const std::string page_context = |
| metrics::OmniboxEventProto::PageClassification_Name(page_classification); |
| base::UmaHistogramEnumeration( |
| base::StringPrintf("Omnibox.SuggestRequestsSent.%s", page_context), |
| request_type); |
| } |
| |
| void LogResponseCode( |
| RemoteRequestType request_type, |
| int response_code, |
| metrics::OmniboxEventProto::PageClassification page_classification) { |
| base::UmaHistogramSparse("Omnibox.SuggestRequestsSent.HttpResponseCode", |
| response_code); |
| base::UmaHistogramSparse( |
| base::StringPrintf("Omnibox.SuggestRequestsSent.HttpResponseCode.%s", |
| RequestTypeToString(request_type)), |
| response_code); |
| |
| // Don't slice by page classification for invalid page classifications. |
| if (page_classification == metrics::OmniboxEventProto::INVALID_SPEC) { |
| return; |
| } |
| const std::string page_context = |
| metrics::OmniboxEventProto::PageClassification_Name(page_classification); |
| base::UmaHistogramSparse( |
| base::StringPrintf("Omnibox.SuggestRequestsSent.HttpResponseCode.%s", |
| page_context), |
| response_code); |
| base::UmaHistogramSparse( |
| base::StringPrintf("Omnibox.SuggestRequestsSent.HttpResponseCode.%s.%s", |
| page_context, RequestTypeToString(request_type)), |
| response_code); |
| } |
| |
| void LogResponseTimeAndCode( |
| metrics::OmniboxEventProto::PageClassification page_classification, |
| RemoteRequestType request_type, |
| base::TimeDelta response_time, |
| int response_code) { |
| base::UmaHistogramTimes("Omnibox.SuggestRequestsSent.ResponseTime", |
| response_time); |
| base::UmaHistogramTimes( |
| base::StringPrintf("Omnibox.SuggestRequestsSent.ResponseTime.%s", |
| RequestTypeToString(request_type)), |
| response_time); |
| base::UmaHistogramTimes( |
| base::StringPrintf("Omnibox.SuggestRequestsSent.ResponseTime.%s", |
| ResponseCodeToSuccessString(response_code)), |
| response_time); |
| base::UmaHistogramTimes( |
| base::StringPrintf("Omnibox.SuggestRequestsSent.ResponseTime.%s.%s", |
| RequestTypeToString(request_type), |
| ResponseCodeToSuccessString(response_code)), |
| response_time); |
| |
| // Don't slice by page classification for invalid page classifications. |
| if (page_classification == metrics::OmniboxEventProto::INVALID_SPEC) { |
| return; |
| } |
| const std::string page_context = |
| metrics::OmniboxEventProto::PageClassification_Name(page_classification); |
| |
| base::UmaHistogramTimes( |
| base::StringPrintf("Omnibox.SuggestRequestsSent.ResponseTime.%s", |
| page_context), |
| response_time); |
| |
| base::UmaHistogramTimes( |
| base::StringPrintf("Omnibox.SuggestRequestsSent.ResponseTime.%s.%s.%s", |
| page_context, RequestTypeToString(request_type), |
| ResponseCodeToSuccessString(response_code)), |
| response_time); |
| } |
| |
| void AddVariationHeaders(network::ResourceRequest* request, |
| bool is_off_the_record) { |
| // We only care about the experiment IDs from the variations server which do |
| // not require knowing the signed-in state. |
| variations::AppendVariationsHeaderUnknownSignedIn( |
| request->url, |
| is_off_the_record ? variations::InIncognito::kYes |
| : variations::InIncognito::kNo, |
| request); |
| } |
| |
| // Adds query params to the url from the search terms args |
| // Lens overlay suggest inputs. |
| GURL AddLensOverlaySuggestInputsDataToEndpointUrl( |
| TemplateURLRef::SearchTermsArgs search_terms_args, |
| const GURL& url_to_modify) { |
| auto lens_overlay_suggest_inputs = |
| search_terms_args.lens_overlay_suggest_inputs; |
| if (!lens_overlay_suggest_inputs.has_value()) { |
| return url_to_modify; |
| } |
| GURL modified_url = GURL(url_to_modify); |
| bool send_request_and_session_ids = false; |
| bool send_vit = false; |
| |
| if (search_terms_args.page_classification == |
| metrics::OmniboxEventProto::CONTEXTUAL_SEARCHBOX) { |
| send_request_and_session_ids = |
| lens_overlay_suggest_inputs |
| ->send_gsession_vsrid_for_contextual_suggest(); |
| send_vit = true; |
| modified_url = |
| net::AppendOrReplaceQueryParameter(modified_url, "gs_ps", "1"); |
| } else if (search_terms_args.page_classification == |
| metrics::OmniboxEventProto::LENS_SIDE_PANEL_SEARCHBOX) { |
| if (lens_overlay_suggest_inputs |
| ->send_gsession_vsrid_vit_for_lens_suggest()) { |
| send_request_and_session_ids = true; |
| send_vit = true; |
| } |
| if (lens_overlay_suggest_inputs->has_encoded_image_signals()) { |
| modified_url = net::AppendOrReplaceQueryParameter( |
| modified_url, "iil", |
| lens_overlay_suggest_inputs->encoded_image_signals()); |
| } |
| if (lens_overlay_suggest_inputs->send_vsint_for_lens_suggest() && |
| lens_overlay_suggest_inputs |
| ->has_encoded_visual_search_interaction_log_data()) { |
| modified_url = net::AppendOrReplaceQueryParameter( |
| modified_url, "vsint", |
| lens_overlay_suggest_inputs |
| ->encoded_visual_search_interaction_log_data()); |
| } |
| } |
| |
| if (send_vit && |
| lens_overlay_suggest_inputs->has_contextual_visual_input_type()) { |
| modified_url = net::AppendOrReplaceQueryParameter( |
| modified_url, "vit", |
| lens_overlay_suggest_inputs->contextual_visual_input_type()); |
| } |
| |
| if (send_request_and_session_ids) { |
| if (lens_overlay_suggest_inputs->has_encoded_request_id()) { |
| modified_url = net::AppendOrReplaceQueryParameter( |
| modified_url, "vsrid", |
| lens_overlay_suggest_inputs->encoded_request_id()); |
| } |
| if (lens_overlay_suggest_inputs->has_search_session_id()) { |
| modified_url = net::AppendOrReplaceQueryParameter( |
| modified_url, "gsessionid", |
| lens_overlay_suggest_inputs->search_session_id()); |
| } |
| } |
| return modified_url; |
| } |
| |
| } // namespace |
| |
| RemoteSuggestionsService::Delegate::Delegate() = default; |
| |
| RemoteSuggestionsService::Delegate::~Delegate() = default; |
| |
| RemoteSuggestionsService::RemoteSuggestionsService( |
| DocumentSuggestionsService* document_suggestions_service, |
| EnterpriseSearchAggregatorSuggestionsService* |
| enterprise_search_aggregator_suggestions_service, |
| scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory) |
| : document_suggestions_service_(document_suggestions_service), |
| enterprise_search_aggregator_suggestions_service_( |
| enterprise_search_aggregator_suggestions_service), |
| url_loader_factory_(url_loader_factory) { |
| DCHECK(url_loader_factory); |
| } |
| |
| RemoteSuggestionsService::~RemoteSuggestionsService() = default; |
| |
| // TODO(crbug.com/404591650): Create a struct to automate the lifecycle of |
| // `time_request_sent_`. |
| void RemoteSuggestionsService::SetTimeRequestSent( |
| RemoteRequestType request_type, |
| base::TimeTicks time) { |
| time_request_sent_[request_type] = time; |
| } |
| |
| // static |
| GURL RemoteSuggestionsService::EndpointUrl( |
| const TemplateURL& template_url, |
| const TemplateURLRef::SearchTermsArgs& search_terms_args, |
| const SearchTermsData& search_terms_data) { |
| GURL url = GURL(template_url.suggestions_url_ref().ReplaceSearchTerms( |
| search_terms_args, search_terms_data)); |
| |
| // Return early for non-Google template URLs. |
| if (!search::TemplateURLIsGoogle(&template_url, search_terms_data)) { |
| return url; |
| } |
| |
| // Append or replace client= and sclient= based on `page_classification`. |
| switch (search_terms_args.page_classification) { |
| case metrics::OmniboxEventProto::CHROMEOS_APP_LIST: { |
| // Append `sclient=cros-launcher` for CrOS app_list launcher entry point. |
| url = net::AppendOrReplaceQueryParameter(url, "sclient", "cros-launcher"); |
| break; |
| } |
| case metrics::OmniboxEventProto::CONTEXTUAL_SEARCHBOX: |
| case metrics::OmniboxEventProto::SEARCH_SIDE_PANEL_SEARCHBOX: |
| // Append `client=chrome-contextual` for non-multimodal and contextual |
| // lens searchboxes. |
| url = net::AppendOrReplaceQueryParameter(url, "client", |
| "chrome-contextual"); |
| break; |
| case metrics::OmniboxEventProto::LENS_SIDE_PANEL_SEARCHBOX: { |
| // Append `client=chrome-multimodal` for the multimodal lens searchbox. |
| url = net::AppendOrReplaceQueryParameter(url, "client", |
| "chrome-multimodal"); |
| break; |
| } |
| default: |
| break; |
| } |
| url = AddLensOverlaySuggestInputsDataToEndpointUrl(search_terms_args, url); |
| |
| return url; |
| } |
| |
| std::unique_ptr<network::SimpleURLLoader> |
| RemoteSuggestionsService::StartSuggestionsRequest( |
| RemoteRequestType request_type, |
| bool is_off_the_record, |
| const TemplateURL* template_url, |
| TemplateURLRef::SearchTermsArgs search_terms_args, |
| const SearchTermsData& search_terms_data, |
| CompletionCallback completion_callback) { |
| DCHECK(template_url); |
| |
| const GURL suggest_url = |
| EndpointUrl(*template_url, search_terms_args, search_terms_data); |
| if (!suggest_url.is_valid()) { |
| return nullptr; |
| } |
| |
| net::NetworkTrafficAnnotationTag traffic_annotation = |
| net::DefineNetworkTrafficAnnotation("omnibox_suggest", R"( |
| semantics { |
| sender: "Omnibox" |
| description: |
| "Chrome can provide search and navigation suggestions from the " |
| "currently-selected search provider in the omnibox dropdown, based " |
| "on user input." |
| trigger: "User typing in the omnibox." |
| data: |
| "The text typed into the address bar. Potentially other metadata, " |
| "such as the current cursor position or URL of the current page." |
| destination: WEBSITE |
| } |
| policy { |
| cookies_allowed: YES |
| cookies_store: "user" |
| setting: |
| "Users can control this feature via the 'Use a prediction service " |
| "to help complete searches and URLs typed in the address bar' " |
| "setting under 'Privacy'. The feature is enabled by default." |
| chrome_policy { |
| SearchSuggestEnabled { |
| policy_options {mode: MANDATORY} |
| SearchSuggestEnabled: false |
| } |
| } |
| })"); |
| auto request = std::make_unique<network::ResourceRequest>(); |
| request->url = suggest_url; |
| request->load_flags = net::LOAD_DO_NOT_SAVE_COOKIES; |
| // Set the SiteForCookies to the request URL's site to avoid cookie blocking. |
| request->site_for_cookies = net::SiteForCookies::FromUrl(suggest_url); |
| // Add Chrome experiment state to the request headers. |
| AddVariationHeaders(request.get(), is_off_the_record); |
| |
| // Create a unique identifier for the request. |
| const base::UnguessableToken request_id = base::UnguessableToken::Create(); |
| |
| OnRequestCreated(request_id, request.get()); |
| |
| // Make loader and start download. |
| base::ElapsedTimer request_timer; |
| std::unique_ptr<network::SimpleURLLoader> loader = |
| network::SimpleURLLoader::Create(std::move(request), traffic_annotation); |
| loader->DownloadToStringOfUnboundedSizeUntilCrashAndDie( |
| url_loader_factory_.get(), |
| base::BindOnce(&RemoteSuggestionsService::OnRequestCompleted, |
| weak_ptr_factory_.GetWeakPtr(), request_id, request_type, |
| std::move(request_timer), |
| search_terms_args.page_classification, |
| std::move(completion_callback), loader.get())); |
| |
| OnRequestStarted(request_id, request_type, |
| search_terms_args.page_classification, loader.get(), |
| /*request_body*/ ""); |
| return loader; |
| } |
| |
| std::unique_ptr<network::SimpleURLLoader> |
| RemoteSuggestionsService::StartZeroPrefixSuggestionsRequest( |
| RemoteRequestType request_type, |
| bool is_off_the_record, |
| const TemplateURL* template_url, |
| TemplateURLRef::SearchTermsArgs search_terms_args, |
| const SearchTermsData& search_terms_data, |
| CompletionCallback completion_callback) { |
| DCHECK(template_url); |
| |
| const GURL suggest_url = |
| EndpointUrl(*template_url, search_terms_args, search_terms_data); |
| if (!suggest_url.is_valid()) { |
| return nullptr; |
| } |
| |
| net::NetworkTrafficAnnotationTag traffic_annotation = |
| net::DefineNetworkTrafficAnnotation("omnibox_zerosuggest", R"( |
| semantics { |
| sender: "Omnibox" |
| description: |
| "When the user focuses the omnibox, Chrome can provide search or " |
| "navigation suggestions from the default search provider in the " |
| "omnibox dropdown, based on the current page URL.\n" |
| "This is limited to users whose default search engine is Google, " |
| "as no other search engines currently support this kind of " |
| "suggestion." |
| trigger: "The omnibox receives focus." |
| data: "The URL of the current page." |
| destination: GOOGLE_OWNED_SERVICE |
| } |
| policy { |
| cookies_allowed: YES |
| cookies_store: "user" |
| setting: |
| "Users can control this feature via the 'Use a prediction service " |
| "to help complete searches and URLs typed in the address bar' " |
| "settings under 'Privacy'. The feature is enabled by default." |
| chrome_policy { |
| SearchSuggestEnabled { |
| policy_options {mode: MANDATORY} |
| SearchSuggestEnabled: false |
| } |
| } |
| })"); |
| |
| auto request = std::make_unique<network::ResourceRequest>(); |
| request->url = suggest_url; |
| request->load_flags = net::LOAD_DO_NOT_SAVE_COOKIES; |
| if (search_terms_args.bypass_cache) { |
| request->load_flags |= net::LOAD_BYPASS_CACHE; |
| } |
| // Set the SiteForCookies to the request URL's site to avoid cookie blocking. |
| request->site_for_cookies = net::SiteForCookies::FromUrl(suggest_url); |
| // Add Chrome experiment state to the request headers. |
| AddVariationHeaders(request.get(), is_off_the_record); |
| |
| // Create a unique identifier for the request. |
| const base::UnguessableToken request_id = base::UnguessableToken::Create(); |
| |
| OnRequestCreated(request_id, request.get()); |
| |
| // Make loader and start download. |
| base::ElapsedTimer request_timer; |
| std::unique_ptr<network::SimpleURLLoader> loader = |
| network::SimpleURLLoader::Create(std::move(request), traffic_annotation); |
| loader->DownloadToStringOfUnboundedSizeUntilCrashAndDie( |
| url_loader_factory_.get(), |
| base::BindOnce(&RemoteSuggestionsService::OnRequestCompleted, |
| weak_ptr_factory_.GetWeakPtr(), request_id, request_type, |
| std::move(request_timer), |
| search_terms_args.page_classification, |
| std::move(completion_callback), loader.get())); |
| |
| OnRequestStarted(request_id, request_type, |
| search_terms_args.page_classification, loader.get(), |
| /*request_body*/ ""); |
| return loader; |
| } |
| |
| void RemoteSuggestionsService::CreateDocumentSuggestionsRequest( |
| const std::u16string& query, |
| bool is_off_the_record, |
| metrics::OmniboxEventProto::PageClassification page_classification, |
| StartCallback start_callback, |
| CompletionCallback completion_callback) { |
| if (!document_suggestions_service_) { |
| return; |
| } |
| |
| // Create a unique identifier for the request. |
| const base::UnguessableToken request_id = base::UnguessableToken::Create(); |
| |
| base::ElapsedTimer request_timer; |
| document_suggestions_service_->CreateDocumentSuggestionsRequest( |
| query, is_off_the_record, |
| base::BindOnce(&RemoteSuggestionsService::OnRequestCreated, |
| weak_ptr_factory_.GetWeakPtr(), request_id), |
| base::BindOnce(&RemoteSuggestionsService::OnRequestStartedAsync, |
| weak_ptr_factory_.GetWeakPtr(), request_id, |
| /*request_type=*/RemoteRequestType::kDocumentSuggest, |
| page_classification, std::move(start_callback)), |
| base::BindOnce(&RemoteSuggestionsService::OnRequestCompleted, |
| weak_ptr_factory_.GetWeakPtr(), request_id, |
| /*request_type=*/RemoteRequestType::kDocumentSuggest, |
| std::move(request_timer), page_classification, |
| std::move(completion_callback))); |
| } |
| |
| void RemoteSuggestionsService::StopCreatingDocumentSuggestionsRequest() { |
| if (document_suggestions_service_) { |
| document_suggestions_service_->StopCreatingDocumentSuggestionsRequest(); |
| } |
| } |
| |
| void RemoteSuggestionsService:: |
| CreateEnterpriseSearchAggregatorSuggestionsRequest( |
| const std::u16string& query, |
| const GURL& suggest_url, |
| metrics::OmniboxEventProto::PageClassification page_classification, |
| std::vector<int> callback_indexes, |
| std::vector<std::vector<int>> suggestion_types, |
| IndexedStartCallback start_callback, |
| IndexedCompletionCallback completion_callback) { |
| if (!enterprise_search_aggregator_suggestions_service_) { |
| return; |
| } |
| |
| // Create a unique identifier for the request. |
| const base::UnguessableToken request_id = base::UnguessableToken::Create(); |
| |
| enterprise_search_aggregator_suggestions_service_ |
| ->CreateEnterpriseSearchAggregatorSuggestionsRequest( |
| query, suggest_url, callback_indexes, suggestion_types, |
| base::BindRepeating(&RemoteSuggestionsService::OnRequestCreated, |
| weak_ptr_factory_.GetWeakPtr(), request_id), |
| base::BindRepeating( |
| &RemoteSuggestionsService::OnIndexedRequestStartedAsync, |
| weak_ptr_factory_.GetWeakPtr(), request_id, |
| /*request_type=*/ |
| RemoteRequestType::kEnterpriseSearchAggregatorSuggest, |
| page_classification, start_callback), |
| base::BindRepeating( |
| &RemoteSuggestionsService::OnIndexedRequestCompleted, |
| weak_ptr_factory_.GetWeakPtr(), request_id, |
| /*request_type=*/ |
| RemoteRequestType::kEnterpriseSearchAggregatorSuggest, |
| metrics::OmniboxEventProto::INVALID_SPEC, base::TimeTicks::Now(), |
| std::move(completion_callback))); |
| } |
| |
| void RemoteSuggestionsService:: |
| StopCreatingEnterpriseSearchAggregatorSuggestionsRequest() { |
| if (enterprise_search_aggregator_suggestions_service_) { |
| enterprise_search_aggregator_suggestions_service_ |
| ->StopCreatingEnterpriseSearchAggregatorSuggestionsRequest(); |
| } |
| } |
| |
| std::unique_ptr<network::SimpleURLLoader> |
| RemoteSuggestionsService::StartDeletionRequest( |
| const std::string& deletion_url, |
| bool is_off_the_record, |
| CompletionCallback completion_callback) { |
| const GURL url(deletion_url); |
| DCHECK(url.is_valid()); |
| |
| net::NetworkTrafficAnnotationTag traffic_annotation = |
| net::DefineNetworkTrafficAnnotation("omnibox_suggest_deletion", R"( |
| semantics { |
| sender: "Omnibox" |
| description: |
| "When users attempt to delete server-provided personalized search " |
| "or navigation suggestions from the omnibox dropdown, Chrome sends " |
| "a message to the server requesting deletion of the suggestion." |
| trigger: |
| "A user attempt to delete a server-provided omnibox suggestion, " |
| "for which the server provided a custom deletion URL." |
| data: |
| "No user data is explicitly sent with the request, but because the " |
| "requested URL is provided by the server for each specific " |
| "suggestion, it necessarily uniquely identifies the suggestion the " |
| "user is attempting to delete." |
| destination: WEBSITE |
| } |
| policy { |
| cookies_allowed: YES |
| cookies_store: "user" |
| setting: |
| "Since this can only be triggered on seeing server-provided " |
| "suggestions in the omnibox dropdown, whether it is enabled is the " |
| "same as whether those suggestions are enabled.\n" |
| "Users can control this feature via the 'Use a prediction service " |
| "to help complete searches and URLs typed in the address bar' " |
| "setting under 'Privacy'. The feature is enabled by default." |
| chrome_policy { |
| SearchSuggestEnabled { |
| policy_options {mode: MANDATORY} |
| SearchSuggestEnabled: false |
| } |
| } |
| })"); |
| auto request = std::make_unique<network::ResourceRequest>(); |
| request->url = url; |
| // Set the SiteForCookies to the request URL's site to avoid cookie blocking. |
| request->site_for_cookies = net::SiteForCookies::FromUrl(url); |
| // Add Chrome experiment state to the request headers. |
| AddVariationHeaders(request.get(), is_off_the_record); |
| |
| // Create a unique identifier for the request. |
| const base::UnguessableToken request_id = base::UnguessableToken::Create(); |
| |
| OnRequestCreated(request_id, request.get()); |
| |
| // Make loader and start download. |
| base::ElapsedTimer request_timer; |
| std::unique_ptr<network::SimpleURLLoader> loader = |
| network::SimpleURLLoader::Create(std::move(request), traffic_annotation); |
| loader->DownloadToStringOfUnboundedSizeUntilCrashAndDie( |
| url_loader_factory_.get(), |
| base::BindOnce(&RemoteSuggestionsService::OnRequestCompleted, |
| weak_ptr_factory_.GetWeakPtr(), request_id, |
| /*request_type=*/RemoteRequestType::kDeletion, |
| std::move(request_timer), |
| metrics::OmniboxEventProto::INVALID_SPEC, |
| std::move(completion_callback), loader.get())); |
| |
| OnRequestStarted(request_id, /*request_type=*/RemoteRequestType::kDeletion, |
| metrics::OmniboxEventProto::INVALID_SPEC, loader.get(), |
| /*request_body*/ ""); |
| return loader; |
| } |
| |
| void RemoteSuggestionsService::AddObserver(Observer* observer) { |
| observers_.AddObserver(observer); |
| } |
| |
| void RemoteSuggestionsService::RemoveObserver(Observer* observer) { |
| observers_.RemoveObserver(observer); |
| } |
| |
| void RemoteSuggestionsService::SetDelegate(base::WeakPtr<Delegate> delegate) { |
| delegate_ = std::move(delegate); |
| } |
| |
| void RemoteSuggestionsService::set_url_loader_factory_for_testing( |
| scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory) { |
| url_loader_factory_ = std::move(url_loader_factory); |
| } |
| |
| void RemoteSuggestionsService::OnRequestCreated( |
| const base::UnguessableToken& request_id, |
| network::ResourceRequest* request) { |
| // Notify the observers that request has been created. |
| observers_.Notify(&Observer::OnRequestCreated, request_id, request); |
| } |
| |
| void RemoteSuggestionsService::OnRequestStarted( |
| const base::UnguessableToken& request_id, |
| RemoteRequestType request_type, |
| metrics::OmniboxEventProto::PageClassification page_classification, |
| network::SimpleURLLoader* loader, |
| const std::string& request_body) { |
| // Notify the observers that the transfer started. |
| observers_.Notify(&Observer::OnRequestStarted, request_id, loader, |
| request_body); |
| LogRequestSent(request_type, page_classification); |
| } |
| |
| void RemoteSuggestionsService::OnRequestStartedAsync( |
| const base::UnguessableToken& request_id, |
| RemoteRequestType request_type, |
| metrics::OmniboxEventProto::PageClassification page_classification, |
| StartCallback start_callback, |
| std::unique_ptr<network::SimpleURLLoader> loader, |
| const std::string& request_body) { |
| OnRequestStarted(request_id, request_type, page_classification, loader.get(), |
| request_body); |
| std::move(start_callback).Run(std::move(loader)); |
| } |
| |
| void RemoteSuggestionsService::OnIndexedRequestStartedAsync( |
| const base::UnguessableToken& request_id, |
| RemoteRequestType request_type, |
| metrics::OmniboxEventProto::PageClassification page_classification, |
| IndexedStartCallback start_callback, |
| int request_index, |
| std::unique_ptr<network::SimpleURLLoader> loader, |
| const std::string& request_body) { |
| OnRequestStarted(request_id, request_type, page_classification, loader.get(), |
| request_body); |
| std::move(start_callback).Run(request_index, std::move(loader)); |
| } |
| |
| void RemoteSuggestionsService::OnRequestCompleted( |
| const base::UnguessableToken& request_id, |
| RemoteRequestType request_type, |
| base::ElapsedTimer request_timer, |
| metrics::OmniboxEventProto::PageClassification page_classification, |
| CompletionCallback completion_callback, |
| const network::SimpleURLLoader* source, |
| std::unique_ptr<std::string> response_body) { |
| const int response_code = |
| source->ResponseInfo() && source->ResponseInfo()->headers |
| ? source->ResponseInfo()->headers->response_code() |
| : 0; |
| |
| // Notify the observers that the transfer is done. |
| observers_.Notify(&Observer::OnRequestCompleted, request_id, response_code, |
| response_body); |
| LogResponseCode(request_type, response_code, page_classification); |
| LogResponseTimeAndCode(page_classification, request_type, |
| request_timer.Elapsed(), response_code); |
| |
| // Call the completion callback or delegate it. |
| if (delegate_) { |
| delegate_->OnRequestCompleted(source, response_code, |
| std::move(response_body), |
| std::move(completion_callback)); |
| } else { |
| std::move(completion_callback) |
| .Run(source, response_code, std::move(response_body)); |
| } |
| } |
| |
| void RemoteSuggestionsService::OnIndexedRequestCompleted( |
| const base::UnguessableToken& request_id, |
| RemoteRequestType request_type, |
| metrics::OmniboxEventProto::PageClassification page_classification, |
| base::TimeTicks start_time, |
| IndexedCompletionCallback completion_callback, |
| const network::SimpleURLLoader* source, |
| int request_index, |
| std::unique_ptr<std::string> response_body) { |
| const int response_code = |
| source->ResponseInfo() && source->ResponseInfo()->headers |
| ? source->ResponseInfo()->headers->response_code() |
| : 0; |
| // Notify the observers that the transfer is done. |
| observers_.Notify(&Observer::OnRequestCompleted, request_id, response_code, |
| response_body); |
| LogResponseCode(request_type, response_code, page_classification); |
| LogResponseTimeAndCode(page_classification, request_type, |
| base::TimeTicks::Now() - start_time, response_code); |
| |
| // Call the completion callback or delegate it. |
| if (delegate_) { |
| delegate_->OnIndexedRequestCompleted(request_index, source, response_code, |
| std::move(response_body), |
| completion_callback); |
| } else { |
| std::move(completion_callback) |
| .Run(request_index, source, response_code, std::move(response_body)); |
| } |
| } |
