Added cancellable request to network library

PiperOrigin-RevId: 529197083

fastpair/internal/test/BUILD

@@ -14,6 +14,8 @@ cc_library(
     deps = [
         "//internal/network:types",
         "@com_google_absl//absl/functional:any_invocable",
+        "@com_google_absl//absl/status",
+        "@com_google_absl//absl/status:statusor",
     ],
 )
 
@@ -30,6 +32,7 @@ cc_test(
     deps = [
         ":nearby_fastpair_test",
         "//internal/network:types",
+        "//internal/platform/implementation/g3",
         "@com_github_protobuf_matchers//protobuf-matchers",
         "@com_google_absl//absl/container:flat_hash_map",
         "@com_google_absl//absl/functional:any_invocable",

fastpair/internal/test/fast_pair_fake_http_client.h

@@ -16,11 +16,13 @@
 #define THIRD_PARTY_NEARBY_FASTPAIR_INTERNAL_TEST_FAST_PAIR_FAKE_HTTP_CLIENT_H_
 
 #include <functional>
+#include <memory>
 #include <optional>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "absl/status/statusor.h"
 #include "internal/network/http_client.h"
 
 namespace nearby {
@@ -51,6 +53,16 @@ class FastPairFakeHttpClient : public HttpClient {
     request_infos_.push_back(std::move(request_info));
   }
 
+  void StartCancellableRequest(
+      std::unique_ptr<CancellableRequest> request,
+      std::function<void(const absl::StatusOr<HttpResponse>&)> callback)
+      override {}
+
+  absl::StatusOr<HttpResponse> GetResponse(
+      const HttpRequest& request) override {
+    return absl::UnimplementedError("unimplemented");
+  }
+
   // Mock methods
   void CompleteRequest(const absl::StatusOr<HttpResponse>& response,
                        size_t pos = 0) {

internal/network/BUILD

@@ -26,6 +26,7 @@ cc_library(
         "//location/nearby/cpp/sharing:__subpackages__",
     ],
     deps = [
+        "//internal/platform:types",
         "@com_google_absl//absl/container:flat_hash_map",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
@@ -53,9 +54,12 @@ cc_library(
     deps = [
         ":types",
         "//internal/platform:logging",
+        "//internal/platform:types",
         "//internal/platform/implementation:platform",
         "@com_google_absl//absl/base:core_headers",
         "@com_google_absl//absl/container:flat_hash_map",
+        "@com_google_absl//absl/status",
+        "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/strings:str_format",
         "@com_google_absl//absl/synchronization",
     ],
@@ -85,6 +89,8 @@ cc_test(
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/strings",
+        "@com_google_absl//absl/synchronization",
+        "@com_google_absl//absl/time",
         "@com_google_googletest//:gtest_main",
     ],
 )

internal/network/http_client.h

@@ -1,4 +1,4 @@
-// Copyright 2021 Google LLC
+// Copyright 2021-2023 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -16,22 +16,61 @@
 #define THIRD_PARTY_NEARBY_INTERNAL_NETWORK_HTTP_CLIENT_H_
 
 #include <functional>
+#include <memory>
 
 #include "absl/status/statusor.h"
 #include "internal/network/http_request.h"
 #include "internal/network/http_response.h"
+#include "internal/platform/mutex_lock.h"
 
 namespace nearby {
 namespace network {
 
 class HttpClient {
  public:
+  class CancellableRequest {
+   public:
+    explicit CancellableRequest(const HttpRequest& request)
+        : http_request_(request) {}
+    ~CancellableRequest() = default;
+
+    bool is_cancelled() ABSL_LOCKS_EXCLUDED(mutex_) {
+      MutexLock lock(&mutex_);
+      return is_cancelled_;
+    }
+
+    void cancel() ABSL_LOCKS_EXCLUDED(mutex_) {
+      MutexLock lock(&mutex_);
+      is_cancelled_ = true;
+    }
+
+    const HttpRequest& http_request() ABSL_LOCKS_EXCLUDED(mutex_) {
+      MutexLock lock(&mutex_);
+      return http_request_;
+    }
+
+   private:
+    Mutex mutex_;
+    bool is_cancelled_ ABSL_GUARDED_BY(mutex_) = false;
+    HttpRequest http_request_ ABSL_GUARDED_BY(mutex_);
+  };
+
   virtual ~HttpClient() = default;
 
+  // Starts HTTP request in asynchronization mode.
   virtual void StartRequest(
       const HttpRequest& request,
       std::function<void(const absl::StatusOr<HttpResponse>&)> callback) = 0;
 
+  // Starts cancellable request in asynchronization mode.
+  virtual void StartCancellableRequest(
+      std::unique_ptr<CancellableRequest> request,
+      std::function<void(const absl::StatusOr<HttpResponse>&)> callback) = 0;
+
+  // Gets HTTP response in synchronization mode.
+  virtual absl::StatusOr<HttpResponse> GetResponse(
+      const HttpRequest& request) = 0;
+
   // The error may be corrected if retried at a later time.
   static bool IsRetryableHttpError(absl::Status status) {
     return absl::IsUnavailable(status) || absl::IsFailedPrecondition(status);

internal/network/http_client_factory.h

@@ -16,7 +16,6 @@
 #define THIRD_PARTY_NEARBY_INTERNAL_NETWORK_HTTP_CLIENT_FACTORY_H_
 
 #include <memory>
-#include <utility>
 
 #include "internal/network/http_client.h"
 

internal/network/http_client_impl.cc

@@ -1,4 +1,4 @@
-// Copyright 2021 Google LLC
+// Copyright 2021-2023 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -17,13 +17,16 @@
 #include <chrono>  // NOLINT
 #include <functional>
 #include <future>  // NOLINT
+#include <memory>
 #include <ostream>
 #include <sstream>
 #include <utility>
 
+#include "absl/status/status.h"
 #include "internal/network/debug.h"
-#include "internal/platform/implementation/platform.h"
 #include "internal/platform/logging.h"
+#include "internal/platform/mutex_lock.h"
+#include "internal/platform/single_thread_executor.h"
 
 namespace nearby {
 namespace network {
@@ -31,78 +34,105 @@ namespace network {
 void NearbyHttpClient::StartRequest(
     const HttpRequest& request,
     std::function<void(const absl::StatusOr<HttpResponse>&)> callback) {
-  absl::MutexLock lock(&mutex_);
+  MutexLock lock(&mutex_);
   CleanThreads();
 
-  std::future<void> http_thread = std::async(std::launch::async, [&, request,
-                                                                  callback]() {
-    api::WebRequest web_request;
-    web_request.url = request.GetUrl().GetUrlPath();
-    web_request.method = absl::StrCat(request.GetMethodString());
-    for (const auto& header : request.GetAllHeaders()) {
-      for (const auto& value : header.second) {
-        web_request.headers.emplace(header.first, value);
-      }
-    }
-    web_request.body = absl::StrCat(request.GetBody().GetRawData());
+  std::future<void> http_thread = std::async(
+      std::launch::async, [&, request, callback = std::move(callback)]() {
+        NEARBY_LOGS(INFO) << __func__ << ": Start async request to url="
+                          << request.GetUrl().GetUrlPath();
+        absl::StatusOr<HttpResponse> response = InternalGetResponse(request);
+        if (response.ok()) {
+          NEARBY_LOGS(INFO)
+              << __func__
+              << ": Got response from url=" << request.GetUrl().GetUrlPath();
+        } else {
+          NEARBY_LOGS(ERROR) << __func__ << ": Failed to get response from url="
+                             << request.GetUrl().GetUrlPath() << ", status"
+                             << response.status();
+        }
 
-    if (debug::kRequestEnabled) {
-      std::stringstream request_stream;
-      request_stream << "HTTP REQUEST====>" << std::endl;
-      request_stream << web_request.method << " " << web_request.url
-                     << std::endl;
-      for (const auto& header : web_request.headers) {
-        request_stream << header.first << ": " << header.second << std::endl;
-      }
-      request_stream << std::endl;
-      request_stream << "body size: " << request.GetBody().GetRawData().size()
-                     << std::endl;
-      NEARBY_LOGS(VERBOSE) << request_stream.str();
-    }
-
-    absl::StatusOr<api::WebResponse> web_response =
-        api::ImplementationPlatform::SendRequest(web_request);
-
-    if (!web_response.ok()) {
-      if (callback != nullptr) {
-        callback(web_response.status());
-      }
-      return;
-    }
-
-    if (debug::kResponseEnabled) {
-      std::stringstream response_stream;
-      response_stream << "HTTP RESPONSE====>" << std::endl;
-      response_stream << "url: " << web_request.url << std::endl;
-      response_stream << web_response->status_code << " "
-                      << web_response->status_text << std::endl;
-      for (const auto& header : web_response->headers) {
-        response_stream << header.first << ": " << header.second << std::endl;
-      }
-      response_stream << std::endl;
-      response_stream << "body size: " << web_response->body.size()
-                      << std::endl;
-      NEARBY_LOGS(VERBOSE) << response_stream.str();
-    }
-
-    HttpResponse response;
-
-    response.SetStatusCode(
-        static_cast<HttpStatusCode>(web_response->status_code));
-    response.SetReasonPhrase(web_response->status_text);
-    for (const auto& header : web_response->headers) {
-      response.AddHeader(header.first, header.second);
-    }
-    response.SetBody(web_response->body);
-
-    if (callback != nullptr) {
-      callback(response);
-    }
-  });
+        if (callback) {
+          callback(response);
+        }
+        NEARBY_LOGS(INFO) << __func__ << ": Completed request to url="
+                          << request.GetUrl().GetUrlPath();
+      });
 
   http_threads_.push_back(std::move(http_thread));
 }
 
+void NearbyHttpClient::StartCancellableRequest(
+    std::unique_ptr<CancellableRequest> cancellable_request,
+    std::function<void(const absl::StatusOr<HttpResponse>&)> callback) {
+  MutexLock lock(&mutex_);
+  if (cancellable_request == nullptr) {
+    NEARBY_LOGS(ERROR) << __func__ << ": invalid cancellable request.";
+    callback(absl::InvalidArgumentError("invalid cancellable request"));
+    return;
+  }
+  executor_
+      .Execute(
+          [cancellable_request = std::move(cancellable_request),
+           callback = std::move(callback)]() {
+            NEARBY_LOGS(INFO)
+                << __func__ << ": Start async request to url="
+                << cancellable_request->http_request().GetUrl().GetUrlPath();
+            if (cancellable_request->is_cancelled()) {
+              NEARBY_LOGS(WARNING)
+                  << __func__ << ": Async request to url="
+                  << cancellable_request->http_request().GetUrl().GetUrlPath()
+                  << " is cancelled.";
+              return;
+            }
+            absl::StatusOr<HttpResponse> response =
+                InternalGetResponse(cancellable_request->http_request());
+            if (response.ok()) {
+              NEARBY_LOGS(INFO)
+                  << __func__ << ": Got response from url="
+                  << cancellable_request->http_request().GetUrl().GetUrlPath();
+            } else {
+              NEARBY_LOGS(ERROR)
+                  << __func__ << ": Failed to get response from url="
+                  << cancellable_request->http_request().GetUrl().GetUrlPath()
+                  << ", status" << response.status();
+            }
+
+            if (cancellable_request->is_cancelled()) {
+              NEARBY_LOGS(WARNING)
+                  << __func__ << ": Async request to url="
+                  << cancellable_request->http_request().GetUrl().GetUrlPath()
+                  << " is cancelled.";
+              return;
+            }
+
+            if (callback) {
+              callback(response);
+            }
+            NEARBY_LOGS(INFO)
+                << __func__ << ": Completed request to url="
+                << cancellable_request->http_request().GetUrl().GetUrlPath();
+          });
+}
+
+absl::StatusOr<HttpResponse> NearbyHttpClient::GetResponse(
+    const HttpRequest& request) {
+  NEARBY_LOGS(INFO) << __func__ << ": Start request to url="
+                    << request.GetUrl().GetUrlPath();
+
+  absl::StatusOr<HttpResponse> response = InternalGetResponse(request);
+  if (response.ok()) {
+    NEARBY_LOGS(INFO) << __func__ << ": Got response from url="
+                      << request.GetUrl().GetUrlPath();
+  } else {
+    NEARBY_LOGS(ERROR) << __func__ << ": Failed to get response from url="
+                       << request.GetUrl().GetUrlPath() << ", status"
+                       << response.status();
+  }
+
+  return response;
+}
+
 void NearbyHttpClient::CleanThreads() {
   auto it = http_threads_.begin();
 
@@ -117,5 +147,64 @@ void NearbyHttpClient::CleanThreads() {
   }
 }
 
+absl::StatusOr<HttpResponse> NearbyHttpClient::InternalGetResponse(
+    const HttpRequest& request) {
+  api::WebRequest web_request;
+  web_request.url = request.GetUrl().GetUrlPath();
+  web_request.method = absl::StrCat(request.GetMethodString());
+  for (const auto& header : request.GetAllHeaders()) {
+    for (const auto& value : header.second) {
+      web_request.headers.emplace(header.first, value);
+    }
+  }
+  web_request.body = absl::StrCat(request.GetBody().GetRawData());
+
+  if (debug::kRequestEnabled) {
+    std::stringstream request_stream;
+    request_stream << "HTTP REQUEST====>" << std::endl;
+    request_stream << web_request.method << " " << web_request.url << std::endl;
+    for (const auto& header : web_request.headers) {
+      request_stream << header.first << ": " << header.second << std::endl;
+    }
+    request_stream << std::endl;
+    request_stream << "body size: " << request.GetBody().GetRawData().size()
+                   << std::endl;
+    NEARBY_LOGS(VERBOSE) << request_stream.str();
+  }
+
+  absl::StatusOr<api::WebResponse> web_response =
+      api::ImplementationPlatform::SendRequest(web_request);
+
+  if (!web_response.ok()) {
+    return web_response.status();
+  }
+
+  if (debug::kResponseEnabled) {
+    std::stringstream response_stream;
+    response_stream << "HTTP RESPONSE====>" << std::endl;
+    response_stream << "url: " << web_request.url << std::endl;
+    response_stream << web_response->status_code << " "
+                    << web_response->status_text << std::endl;
+    for (const auto& header : web_response->headers) {
+      response_stream << header.first << ": " << header.second << std::endl;
+    }
+    response_stream << std::endl;
+    response_stream << "body size: " << web_response->body.size() << std::endl;
+    NEARBY_LOGS(VERBOSE) << response_stream.str();
+  }
+
+  HttpResponse response;
+
+  response.SetStatusCode(
+      static_cast<HttpStatusCode>(web_response->status_code));
+  response.SetReasonPhrase(web_response->status_text);
+  for (const auto& header : web_response->headers) {
+    response.AddHeader(header.first, header.second);
+  }
+  response.SetBody(web_response->body);
+
+  return response;
+}
+
 }  // namespace network
 }  // namespace nearby

internal/network/http_client_impl.h

@@ -1,4 +1,4 @@
-// Copyright 2022 Google LLC
+// Copyright 2022-2023 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -16,14 +16,15 @@
 #define THIRD_PARTY_NEARBY_INTERNAL_NETWORK_HTTP_CLIENT_IMPL_H_
 
 #include <functional>
-#include <future> // NOLINT
-#include <thread> // NOLINT
-#include <utility>
+#include <future>  // NOLINT
+#include <memory>
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/synchronization/mutex.h"
 #include "internal/network/http_client.h"
+#include "internal/network/http_request.h"
+#include "internal/platform/mutex.h"
+#include "internal/platform/single_thread_executor.h"
 
 namespace nearby {
 namespace network {
@@ -42,10 +43,21 @@ class NearbyHttpClient : public HttpClient {
                     std::function<void(const absl::StatusOr<HttpResponse>&)>
                         callback) override ABSL_LOCKS_EXCLUDED(mutex_);
 
+  void StartCancellableRequest(
+      std::unique_ptr<CancellableRequest> request,
+      std::function<void(const absl::StatusOr<HttpResponse>&)> callback)
+      override ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Gets HTTP response in synchronization mode.
+  absl::StatusOr<HttpResponse> GetResponse(const HttpRequest& request) override;
+
  private:
   void CleanThreads() ABSL_SHARED_LOCKS_REQUIRED(mutex_);
+  static absl::StatusOr<HttpResponse> InternalGetResponse(
+      const HttpRequest& request);
 
-  absl::Mutex mutex_;
+  Mutex mutex_;
+  SingleThreadExecutor executor_;
   std::vector<std::future<void>> http_threads_ ABSL_GUARDED_BY(mutex_);
 };
 

internal/network/http_client_impl_test.cc

@@ -1,4 +1,4 @@
-// Copyright 2021 Google LLC
+// Copyright 2021-2023 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -14,9 +14,10 @@
 
 #include "internal/network/http_client_impl.h"
 
-#include <cstddef>
 #include <map>
+#include <memory>
 #include <string>
+#include <utility>
 
 #include "gmock/gmock.h"
 #include "protobuf-matchers/protocol-buffer-matchers.h"
@@ -26,6 +27,9 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "absl/synchronization/notification.h"
+#include "absl/time/time.h"
+#include "internal/network/http_client.h"
 #include "internal/network/http_status_code.h"
 #include "internal/platform/implementation/http_loader.h"
 #include "internal/platform/implementation/platform.h"
@@ -38,6 +42,7 @@ struct HttpTestContext {
   WebRequest web_request;
   WebResponse web_response;
   absl::Status status;
+  absl::Duration api_time;
 };
 
 HttpTestContext* GetContext() {
@@ -51,6 +56,9 @@ HttpTestContext* GetContext() {
 absl::StatusOr<WebResponse> ImplementationPlatform::SendRequest(
     const WebRequest& request) {
   GetContext()->web_request = request;
+  if (GetContext()->api_time != absl::ZeroDuration()) {
+    absl::SleepFor(GetContext()->api_time);
+  }
   if (GetContext()->status.ok()) {
     return GetContext()->web_response;
   }
@@ -69,6 +77,7 @@ class NearbyHttpClientTest : public ::testing::Test {
     api::GetContext()->web_request = api::WebRequest();
     api::GetContext()->web_response = api::WebResponse();
     api::GetContext()->status = absl::Status();
+    api::GetContext()->api_time = absl::ZeroDuration();
   }
 
   void MockFailedResponse(absl::Status status) {
@@ -89,17 +98,16 @@ class NearbyHttpClientTest : public ::testing::Test {
 
   api::WebRequest GetWebRequest() { return api::GetContext()->web_request; }
 
-  absl::StatusOr<HttpResponse> GetResponse(
+  absl::StatusOr<HttpRequest> MakeHttpRequest(
       absl::string_view url, HttpRequestMethod method,
       const std::multimap<std::string, std::string>& headers,
       absl::string_view body) {
-    absl::StatusOr<HttpResponse> result;
     absl::StatusOr<Url> request_url = Url::Create(url);
     if (!request_url.ok()) {
       return request_url.status();
     }
 
-    HttpRequest request{request_url.value()};
+    HttpRequest request{*request_url};
     auto it = headers.begin();
     while (it != headers.end()) {
       request.AddHeader(it->first, it->second);
@@ -107,11 +115,25 @@ class NearbyHttpClientTest : public ::testing::Test {
     }
     request.SetMethod(method);
     request.SetBody(body);
+    return request;
+  }
+
+  absl::StatusOr<HttpResponse> GetResponseAsync(
+      absl::string_view url, HttpRequestMethod method,
+      const std::multimap<std::string, std::string>& headers,
+      absl::string_view body) {
+    absl::StatusOr<HttpResponse> result;
+
+    absl::StatusOr<HttpRequest> request =
+        MakeHttpRequest(url, method, headers, body);
+    if (!request.ok()) {
+      return request.status();
+    }
 
     absl::Notification notification;
     client_.StartRequest(
-        request, [&result, &notification](
-                     const absl::StatusOr<HttpResponse>& http_response) {
+        *request, [&result, &notification](
+                      const absl::StatusOr<HttpResponse>& http_response) {
           result = http_response;
           notification.Notify();
         });
@@ -121,6 +143,20 @@ class NearbyHttpClientTest : public ::testing::Test {
     return result;
   }
 
+  absl::StatusOr<HttpResponse> GetResponse(
+      absl::string_view url, HttpRequestMethod method,
+      const std::multimap<std::string, std::string>& headers,
+      absl::string_view body) {
+    absl::StatusOr<HttpResponse> result;
+    absl::StatusOr<HttpRequest> request =
+        MakeHttpRequest(url, method, headers, body);
+    if (!request.ok()) {
+      return request.status();
+    }
+
+    return client_.GetResponse(*request);
+  }
+
   void CheckHeader(const std::multimap<std::string, std::string>& headers,
                    absl::string_view key, absl::string_view expected_value) {
     auto it = headers.find(std::string(key));
@@ -138,6 +174,8 @@ class NearbyHttpClientTest : public ::testing::Test {
     EXPECT_TRUE(found);
   }
 
+  NearbyHttpClient& client() { return client_; }
+
  private:
   NearbyHttpClient client_;
 };
@@ -146,8 +184,8 @@ namespace {
 TEST_F(NearbyHttpClientTest, TestGet) {
   MockResponse(HttpStatusCode::kHttpOk, "OK", {{"Content_Type", "text/html"}},
                "web content");
-  auto result =
-      GetResponse("http://www.google.com", HttpRequestMethod::kGet, {}, "");
+  auto result = GetResponseAsync("http://www.google.com",
+                                 HttpRequestMethod::kGet, {}, "");
 
   // Checks request.
   api::WebRequest web_request = GetWebRequest();
@@ -165,8 +203,8 @@ TEST_F(NearbyHttpClientTest, TestGet) {
 TEST_F(NearbyHttpClientTest, TestGetWithQuery) {
   MockResponse(HttpStatusCode::kHttpOk, "OK", {{"Content_Type", "text/html"}},
                "web content");
-  auto result = GetResponse("http://www.google.com?name=name1&age=36",
-                            HttpRequestMethod::kGet, {}, "");
+  auto result = GetResponseAsync("http://www.google.com?name=name1&age=36",
+                                 HttpRequestMethod::kGet, {}, "");
 
   // Checks request.
   api::WebRequest web_request = GetWebRequest();
@@ -180,8 +218,8 @@ TEST_F(NearbyHttpClientTest, TestGetWithQuery) {
 
 TEST_F(NearbyHttpClientTest, TestGetWithErrorResult) {
   MockFailedResponse(absl::InternalError("no connection."));
-  auto result = GetResponse("http://www.google.com?name=name1&age=36",
-                            HttpRequestMethod::kGet, {}, "");
+  auto result = GetResponseAsync("http://www.google.com?name=name1&age=36",
+                                 HttpRequestMethod::kGet, {}, "");
 
   // Checks request.
   api::WebRequest web_request = GetWebRequest();
@@ -192,6 +230,24 @@ TEST_F(NearbyHttpClientTest, TestGetWithErrorResult) {
   EXPECT_FALSE(result.ok());
 }
 
+TEST_F(NearbyHttpClientTest, TestPostAsync) {
+  MockResponse(HttpStatusCode::kHttpNoContent, "OK",
+               {{"Content_Type", "text/html"}}, "");
+  auto result = GetResponseAsync("http://www.google.com",
+                                 HttpRequestMethod::kPost, {}, "");
+
+  // Checks request.
+  api::WebRequest web_request = GetWebRequest();
+  EXPECT_EQ(web_request.url, "http://www.google.com");
+  EXPECT_EQ(web_request.method, "POST");
+
+  // Checks response.
+  ASSERT_TRUE(result.ok());
+  EXPECT_EQ(result->GetStatusCode(), HttpStatusCode::kHttpNoContent);
+  HttpResponseBody body = result->GetBody();
+  EXPECT_TRUE(body.empty());
+}
+
 TEST_F(NearbyHttpClientTest, TestPost) {
   MockResponse(HttpStatusCode::kHttpNoContent, "OK",
                {{"Content_Type", "text/html"}}, "");
@@ -210,12 +266,12 @@ TEST_F(NearbyHttpClientTest, TestPost) {
   EXPECT_TRUE(body.empty());
 }
 
-TEST_F(NearbyHttpClientTest, TestPostWithHeader) {
+TEST_F(NearbyHttpClientTest, TestPostWithHeaderAsync) {
   MockResponse(HttpStatusCode::kHttpNoContent, "OK",
                {{"Content_Type", "text/html"}}, "");
   auto result =
-      GetResponse("http://www.google.com", HttpRequestMethod::kPost,
-                  {{"Content_Type", "text/json"}, {"size", "596"}}, "");
+      GetResponseAsync("http://www.google.com", HttpRequestMethod::kPost,
+                       {{"Content_Type", "text/json"}, {"size", "596"}}, "");
 
   // Checks request.
   api::WebRequest web_request = GetWebRequest();
@@ -231,11 +287,11 @@ TEST_F(NearbyHttpClientTest, TestPostWithHeader) {
   EXPECT_EQ(result->GetBody().GetRawData(), "");
 }
 
-TEST_F(NearbyHttpClientTest, TestPostWithErrorResult) {
+TEST_F(NearbyHttpClientTest, TestPostWithErrorResultAsync) {
   MockFailedResponse(absl::UnauthenticatedError("no user."));
   auto result =
-      GetResponse("http://www.google.com", HttpRequestMethod::kPost,
-                  {{"Content_Type", "text/json"}, {"size", "596"}}, "");
+      GetResponseAsync("http://www.google.com", HttpRequestMethod::kPost,
+                       {{"Content_Type", "text/json"}, {"size", "596"}}, "");
 
   // Checks request.
   api::WebRequest web_request = GetWebRequest();
@@ -249,11 +305,11 @@ TEST_F(NearbyHttpClientTest, TestPostWithErrorResult) {
   ASSERT_FALSE(result.ok());
 }
 
-TEST_F(NearbyHttpClientTest, TestRequestWithCleanThreads) {
+TEST_F(NearbyHttpClientTest, TestRequestWithCleanThreadsAsync) {
   MockResponse(HttpStatusCode::kHttpOk, "OK", {{"Content_Type", "text/html"}},
                "web content");
-  auto result =
-      GetResponse("http://www.google.com", HttpRequestMethod::kGet, {}, "");
+  auto result = GetResponseAsync("http://www.google.com",
+                                 HttpRequestMethod::kGet, {}, "");
 
   // Checks request.
   api::WebRequest web_request = GetWebRequest();
@@ -263,11 +319,84 @@ TEST_F(NearbyHttpClientTest, TestRequestWithCleanThreads) {
   // Checks response.
   ASSERT_TRUE(result.ok());
 
-  result =
-      GetResponse("http://www.youtube.com", HttpRequestMethod::kGet, {}, "");
+  result = GetResponseAsync("http://www.youtube.com", HttpRequestMethod::kGet,
+                            {}, "");
   ASSERT_TRUE(result.ok());
 }
 
+TEST_F(NearbyHttpClientTest, TestCancellableRequestAsync) {
+  absl::StatusOr<HttpRequest> request =
+      MakeHttpRequest("http://www.google.com", HttpRequestMethod::kGet, {}, "");
+  MockResponse(HttpStatusCode::kHttpOk, "OK", {{"Content_Type", "text/html"}},
+               "web content");
+  auto cancellable_request =
+      std::make_unique<HttpClient::CancellableRequest>(*request);
+  absl::StatusOr<HttpResponse> result;
+  absl::Notification notification;
+  client().StartCancellableRequest(
+      std::move(cancellable_request),
+      [&](const absl::StatusOr<HttpResponse>& response) {
+        result = response;
+        notification.Notify();
+      });
+  EXPECT_TRUE(notification.WaitForNotificationWithTimeout(absl::Seconds(1)));
+
+  // Checks request.
+  api::WebRequest web_request = GetWebRequest();
+  EXPECT_EQ(web_request.url, "http://www.google.com");
+  EXPECT_EQ(web_request.method, "GET");
+
+  // Checks response.
+  ASSERT_TRUE(result.ok());
+}
+
+TEST_F(NearbyHttpClientTest, TestCancelCancellableRequestAsync) {
+  absl::StatusOr<HttpRequest> request =
+      MakeHttpRequest("http://www.google.com", HttpRequestMethod::kGet, {}, "");
+  MockResponse(HttpStatusCode::kHttpOk, "OK", {{"Content_Type", "text/html"}},
+               "web content");
+  api::GetContext()->api_time = absl::Milliseconds(300);
+  auto cancellable_request =
+      std::make_unique<HttpClient::CancellableRequest>(*request);
+  HttpClient::CancellableRequest* raw_request = cancellable_request.get();
+  absl::StatusOr<HttpResponse> result;
+  absl::Notification notification;
+  client().StartCancellableRequest(
+      std::move(cancellable_request),
+      [&](const absl::StatusOr<HttpResponse>& response) {
+        result = response;
+        notification.Notify();
+      });
+  absl::SleepFor(absl::Milliseconds(50));
+  raw_request->cancel();
+  EXPECT_FALSE(notification.WaitForNotificationWithTimeout(absl::Seconds(1)));
+}
+
+TEST_F(NearbyHttpClientTest,
+       TestDisposeClientWhenCancellableRequestRunningAsync) {
+  absl::StatusOr<HttpRequest> request =
+      MakeHttpRequest("http://www.google.com", HttpRequestMethod::kGet, {}, "");
+  MockResponse(HttpStatusCode::kHttpOk, "OK", {{"Content_Type", "text/html"}},
+               "web content");
+  api::GetContext()->api_time = absl::Milliseconds(300);
+  auto cancellable_request =
+      std::make_unique<HttpClient::CancellableRequest>(*request);
+  HttpClient::CancellableRequest* raw_request = cancellable_request.get();
+  absl::StatusOr<HttpResponse> result;
+  absl::Notification notification;
+  auto client = std::make_unique<NearbyHttpClient>();
+  client->StartCancellableRequest(
+      std::move(cancellable_request),
+      [&](const absl::StatusOr<HttpResponse>& response) {
+        result = response;
+        notification.Notify();
+      });
+  absl::SleepFor(absl::Milliseconds(50));
+  raw_request->cancel();
+  client.reset();
+  EXPECT_FALSE(notification.WaitForNotificationWithTimeout(absl::Seconds(1)));
+}
+
 }  // namespace
 }  // namespace network
 }  // namespace nearby

internal/platform/BUILD

@@ -349,6 +349,7 @@ cc_library(
         "//internal/base:__subpackages__",
         "//internal/flags:__subpackages__",
         "//internal/interop:__pkg__",
+        "//internal/network:__subpackages__",
         "//internal/platform/implementation/windows:__subpackages__",
         "//internal/preferences:__subpackages__",
         "//internal/test:__subpackages__",