sync_stopped_reporter.cc 6.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169
  1. // Copyright 2015 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "components/sync/driver/sync_stopped_reporter.h"
  5. #include <utility>
  6. #include "base/bind.h"
  7. #include "base/check.h"
  8. #include "base/location.h"
  9. #include "base/metrics/histogram_functions.h"
  10. #include "base/strings/stringprintf.h"
  11. #include "base/task/sequenced_task_runner.h"
  12. #include "base/threading/sequenced_task_runner_handle.h"
  13. #include "components/sync/protocol/sync.pb.h"
  14. #include "net/base/load_flags.h"
  15. #include "net/http/http_status_code.h"
  16. #include "net/traffic_annotation/network_traffic_annotation.h"
  17. #include "services/network/public/cpp/resource_request.h"
  18. #include "services/network/public/cpp/shared_url_loader_factory.h"
  19. #include "services/network/public/cpp/simple_url_loader.h"
  20. #include "services/network/public/mojom/url_response_head.mojom.h"
  21. namespace {
  22. const char kEventEndpoint[] = "event";
  23. // The request is tiny, so even on poor connections 10 seconds should be
  24. // plenty of time. Since sync is off when this request is started, we don't
  25. // want anything sync-related hanging around for very long from a human
  26. // perspective either. This seems like a good compromise.
  27. constexpr base::TimeDelta kRequestTimeout = base::Seconds(10);
  28. void LogSyncStoppedRequestTimeout(bool timed_out) {
  29. base::UmaHistogramBoolean("Sync.SyncStoppedURLFetchTimedOut", timed_out);
  30. }
  31. void LogSyncStoppedRequestResult(const network::SimpleURLLoader& url_loader) {
  32. int http_status_code = -1;
  33. if (url_loader.ResponseInfo() && url_loader.ResponseInfo()->headers) {
  34. http_status_code = url_loader.ResponseInfo()->headers->response_code();
  35. }
  36. const int net_error_code = url_loader.NetError();
  37. const bool request_succeeded =
  38. net_error_code == net::OK && http_status_code != -1;
  39. if (request_succeeded) {
  40. LogSyncStoppedRequestTimeout(/*timed_out=*/false);
  41. }
  42. base::UmaHistogramSparse(
  43. "Sync.SyncStoppedURLFetchResponse",
  44. request_succeeded ? http_status_code : net_error_code);
  45. }
  46. } // namespace
  47. namespace syncer {
  48. SyncStoppedReporter::SyncStoppedReporter(
  49. const GURL& sync_service_url,
  50. const std::string& user_agent,
  51. scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
  52. ResultCallback callback)
  53. : sync_event_url_(GetSyncEventURL(sync_service_url)),
  54. user_agent_(user_agent),
  55. url_loader_factory_(std::move(url_loader_factory)),
  56. callback_(std::move(callback)) {
  57. DCHECK(!sync_service_url.is_empty());
  58. DCHECK(!user_agent_.empty());
  59. DCHECK(url_loader_factory_);
  60. }
  61. SyncStoppedReporter::~SyncStoppedReporter() = default;
  62. void SyncStoppedReporter::ReportSyncStopped(const std::string& access_token,
  63. const std::string& cache_guid,
  64. const std::string& birthday) {
  65. DCHECK(!access_token.empty());
  66. DCHECK(!cache_guid.empty());
  67. DCHECK(!birthday.empty());
  68. // Make the request proto with the GUID identifying this client.
  69. sync_pb::EventRequest event_request;
  70. sync_pb::SyncDisabledEvent* sync_disabled_event =
  71. event_request.mutable_sync_disabled();
  72. sync_disabled_event->set_cache_guid(cache_guid);
  73. sync_disabled_event->set_store_birthday(birthday);
  74. std::string msg;
  75. event_request.SerializeToString(&msg);
  76. net::NetworkTrafficAnnotationTag traffic_annotation =
  77. net::DefineNetworkTrafficAnnotation("sync_stop_reporter", R"(
  78. semantics {
  79. sender: "Chrome Sync"
  80. description:
  81. "A network request to inform Chrome Sync that sync has been "
  82. "disabled for this device."
  83. trigger: "User disables sync."
  84. data: "Sync device identifier and metadata."
  85. destination: GOOGLE_OWNED_SERVICE
  86. }
  87. policy {
  88. cookies_allowed: NO
  89. setting: "This feature cannot be disabled by settings."
  90. chrome_policy {
  91. SyncDisabled {
  92. policy_options {mode: MANDATORY}
  93. SyncDisabled: true
  94. }
  95. }
  96. })");
  97. auto resource_request = std::make_unique<network::ResourceRequest>();
  98. resource_request->url = sync_event_url_;
  99. resource_request->load_flags =
  100. net::LOAD_BYPASS_CACHE | net::LOAD_DISABLE_CACHE;
  101. resource_request->credentials_mode = network::mojom::CredentialsMode::kOmit;
  102. resource_request->method = "POST";
  103. resource_request->headers.SetHeader(
  104. net::HttpRequestHeaders::kAuthorization,
  105. base::StringPrintf("Bearer %s", access_token.c_str()));
  106. resource_request->headers.SetHeader(net::HttpRequestHeaders::kUserAgent,
  107. user_agent_);
  108. simple_url_loader_ = network::SimpleURLLoader::Create(
  109. std::move(resource_request), traffic_annotation);
  110. simple_url_loader_->AttachStringForUpload(msg, "application/octet-stream");
  111. simple_url_loader_->DownloadToStringOfUnboundedSizeUntilCrashAndDie(
  112. url_loader_factory_.get(),
  113. base::BindOnce(&SyncStoppedReporter::OnSimpleLoaderComplete,
  114. base::Unretained(this)));
  115. timer_.Start(FROM_HERE, kRequestTimeout, this,
  116. &SyncStoppedReporter::OnTimeout);
  117. }
  118. void SyncStoppedReporter::OnSimpleLoaderComplete(
  119. std::unique_ptr<std::string> response_body) {
  120. DCHECK(simple_url_loader_);
  121. LogSyncStoppedRequestResult(*simple_url_loader_);
  122. Result result = response_body ? RESULT_SUCCESS : RESULT_ERROR;
  123. simple_url_loader_.reset();
  124. timer_.Stop();
  125. if (!callback_.is_null()) {
  126. base::SequencedTaskRunnerHandle::Get()->PostTask(
  127. FROM_HERE, base::BindOnce(std::move(callback_), result));
  128. }
  129. }
  130. void SyncStoppedReporter::OnTimeout() {
  131. LogSyncStoppedRequestTimeout(/*timed_out=*/true);
  132. simple_url_loader_.reset();
  133. if (!callback_.is_null()) {
  134. base::SequencedTaskRunnerHandle::Get()->PostTask(
  135. FROM_HERE, base::BindOnce(std::move(callback_), RESULT_TIMEOUT));
  136. }
  137. }
  138. // Static.
  139. GURL SyncStoppedReporter::GetSyncEventURL(const GURL& sync_service_url) {
  140. std::string path = sync_service_url.path();
  141. if (path.empty() || *path.rbegin() != '/') {
  142. path += '/';
  143. }
  144. path += kEventEndpoint;
  145. GURL::Replacements replacements;
  146. replacements.SetPathStr(path);
  147. return sync_service_url.ReplaceComponents(replacements);
  148. }
  149. } // namespace syncer