[#41] Implement simple networking stack based on libcurl

CMakeLists.txt

@@ -75,6 +75,8 @@ message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
 find_package(Threads REQUIRED)
 # GLOG
 find_package(glog CONFIG REQUIRED)
+# curl
+find_package(CURL CONFIG REQUIRED)
 
 
 #

examples/simple/main.cc

@@ -1,9 +1,11 @@
 #include <thread>
 
 #include "base/bind.h"
+#include "base/bind_post_task.h"
 #include "base/callback.h"
 #include "base/init.h"
 #include "base/logging.h"
+#include "base/net/simple_url_loader.h"
 #include "base/synchronization/auto_signaller.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
@@ -138,8 +140,61 @@ void ThreadPoolSingleThreadExample() {
   pool.Stop();
 }
 
+void NetExample() {
+  base::Thread thread{};
+  thread.Start();
+
+  base::WaitableEvent finished_event{};
+  auto response_callback = base::BindOnce(
+      [](base::WaitableEvent* event, base::net::ResourceResponse response) {
+        LOG(INFO) << "Result: " << static_cast<int>(response.result);
+        LOG(INFO) << "HTTP code: " << response.code;
+        LOG(INFO) << "Final URL: " << response.final_url;
+        LOG(INFO) << "Downloaded " << response.data.size() << " bytes";
+        LOG(INFO) << "Latency: " << response.timing_connect.InMilliseconds()
+                  << "ms";
+        LOG(INFO) << "Headers";
+        for (const auto& [h, v] : response.headers) {
+          LOG(INFO) << "  " << h << ": " << v;
+        }
+        LOG(INFO) << "Content:\n"
+                  << std::string{response.data.begin(), response.data.end()};
+        event->Signal();
+      },
+      &finished_event);
+
+  // Try to download and signal on finish
+  base::net::SimpleUrlLoader::DownloadUnbounded(
+      base::net::ResourceRequest{
+          "https://www.google.com/robots.txt",
+          base::net::kDefaultHeaders,
+          base::net::kNoTimeout,
+          base::net::kNoTimeout,
+          true,
+          true,
+      },
+      base::BindPostTask(thread.TaskRunner(), std::move(response_callback),
+                         FROM_HERE));
+
+  // Timeout = 5s
+  thread.TaskRunner()->PostDelayedTask(
+      FROM_HERE,
+      base::BindOnce(
+          [](base::WaitableEvent* event) {
+            LOG(WARNING) << "Failed to download in 5 seconds";
+            event->Signal();
+          },
+          &finished_event),
+      base::Seconds(5));
+
+  finished_event.Wait();
+}
+
 int main(int argc, char* argv[]) {
-  base::Initialize(argc, argv);
+  base::InitOptions init_options;
+  init_options.InitializeNetworking = true;
+
+  base::Initialize(argc, argv, std::move(init_options));
 
   const auto timer = base::ElapsedTimer{};
 
@@ -149,6 +204,8 @@ int main(int argc, char* argv[]) {
   ThreadPoolSequencedExample();
   ThreadPoolSingleThreadExample();
 
+  NetExample();
+
   LOG(INFO) << "Example finished in " << timer.Elapsed().InMillisecondsF()
             << "ms";
 

src/CMakeLists.txt

@@ -32,77 +32,87 @@ target_include_directories(libbase PUBLIC
 target_link_libraries(libbase PUBLIC
   ${LIBBASE_LINK_FLAGS}
   Threads::Threads
-  glog::glog)
+  glog::glog
+  CURL::libcurl)
 
 target_sources(libbase
   PRIVATE
     base/auto_reset.h
     base/barrier_callback.h
     base/barrier_closure.cc
     base/barrier_closure.h
-    base/bind.h
     base/bind_internals.h
     base/bind_post_task.h
-    base/callback.h
+    base/bind.h
     base/callback_forward.h
     base/callback_helpers.cc
     base/callback_helpers.h
     base/callback_iface.h
     base/callback_internals.h
+    base/callback.h
     base/init.cc
     base/init.h
     base/logging.cc
     base/logging.h
     base/memory/weak_ptr.h
-    base/message_loop/message_loop.h
     base/message_loop/message_loop_impl.cc
     base/message_loop/message_loop_impl.h
-    base/message_loop/message_pump.h
+    base/message_loop/message_loop.h
     base/message_loop/message_pump_impl.cc
     base/message_loop/message_pump_impl.h
+    base/message_loop/message_pump.h
+    base/net/impl/net_thread_impl.cc
+    base/net/impl/net_thread_impl.h
+    base/net/impl/net_thread.cc
+    base/net/impl/net_thread.h
+    base/net/resource_request.h
+    base/net/resource_response.h
+    base/net/result.h
+    base/net/simple_url_loader.cc
+    base/net/simple_url_loader.h
     base/sequence_checker.cc
     base/sequence_checker.h
     base/sequence_id.cc
     base/sequence_id.h
-    base/sequenced_task_runner.h
     base/sequenced_task_runner_helpers.cc
     base/sequenced_task_runner_helpers.h
     base/sequenced_task_runner_internals.h
+    base/sequenced_task_runner.h
     base/single_thread_task_runner.h
     base/source_location.h
     base/synchronization/auto_signaller.cc
     base/synchronization/auto_signaller.h
     base/synchronization/waitable_event.cc
     base/synchronization/waitable_event.h
+    base/task_runner_internals.h
     base/task_runner.cc
     base/task_runner.h
-    base/task_runner_internals.h
-    base/threading/delayed_task_manager.cc
-    base/threading/delayed_task_manager.h
     base/threading/delayed_task_manager_shared_instance.cc
     base/threading/delayed_task_manager_shared_instance.h
+    base/threading/delayed_task_manager.cc
+    base/threading/delayed_task_manager.h
     base/threading/sequenced_task_runner_handle.cc
     base/threading/sequenced_task_runner_handle.h
     base/threading/task_runner_impl.cc
     base/threading/task_runner_impl.h
-    base/threading/thread.cc
-    base/threading/thread.h
     base/threading/thread_pool.cc
     base/threading/thread_pool.h
-    base/time/time.cc
-    base/time/time.h
+    base/threading/thread.cc
+    base/threading/thread.h
     base/time/time_delta.cc
     base/time/time_delta.h
     base/time/time_ticks.cc
     base/time/time_ticks.h
+    base/time/time.cc
+    base/time/time.h
     base/timer/elapsed_timer.cc
     base/timer/elapsed_timer.h
     base/trace_event/trace_argument_packer.h
     base/trace_event/trace_async.h
     base/trace_event/trace_complete.h
     base/trace_event/trace_counter.h
-    base/trace_event/trace_event.h
     base/trace_event/trace_event_register.h
+    base/trace_event/trace_event.h
     base/trace_event/trace_events.cc
     base/trace_event/trace_events.h
     base/trace_event/trace_flow.h

src/base/init.cc

@@ -1,27 +1,51 @@
 #include "base/init.h"
 
 #include "base/logging.h"
+#include "base/net/impl/net_thread.h"
 
 namespace base {
 
+namespace {
+InitOptions g_init_options;
+}
+
 // NOLINTNEXTLINE(modernize-avoid-c-arrays)
-void Initialize(int /*argc*/, char* argv[]) {
-  FLAGS_logtostderr = true;
+void Initialize(int /*argc*/, char* argv[], InitOptions options) {
+  g_init_options = options;
+
+  FLAGS_logtostderr = g_init_options.LogToStderr;
 
   google::InitGoogleLogging(argv[0]);
   google::InstallPrefixFormatter(&detail::LogFormatter);
   google::InstallFailureSignalHandler();
+
+  if (g_init_options.InitializeNetworking) {
+    // Initialize Networking thread
+    net::NetThread::GetInstance().Start();
+  }
 }
 
 // NOLINTNEXTLINE(modernize-avoid-c-arrays)
-void InitializeForTests(int /*argc*/, char* argv[]) {
-  FLAGS_logtostderr = true;
+void InitializeForTests(int /*argc*/, char* argv[], InitOptions options) {
+  g_init_options = options;
+
+  FLAGS_logtostderr = g_init_options.LogToStderr;
 
   google::InitGoogleLogging(argv[0]);
   google::InstallPrefixFormatter(&detail::LogFormatter);
+
+  if (g_init_options.InitializeNetworking) {
+    // Initialize Networking thread
+    net::NetThread::GetInstance().Start();
+  }
 }
 
 void Deinitialize() {
+  if (g_init_options.InitializeNetworking) {
+    // Deinitialize Networking thread
+    net::NetThread::GetInstance().Stop();
+  }
+
   google::ShutdownGoogleLogging();
 }
 

src/base/init.h

@@ -2,10 +2,18 @@
 
 namespace base {
 
+struct InitOptions {
+  // Logging
+  bool LogToStderr = true;
+
+  // Networking
+  bool InitializeNetworking = false;
+};
+
 // NOLINTNEXTLINE(modernize-avoid-c-arrays)
-void Initialize(int argc, char* argv[]);
+void Initialize(int argc, char* argv[], InitOptions options);
 // NOLINTNEXTLINE(modernize-avoid-c-arrays)
-void InitializeForTests(int argc, char* argv[]);
+void InitializeForTests(int argc, char* argv[], InitOptions options);
 void Deinitialize();
 
 }  // namespace base

src/base/net/impl/net_thread.cc

@@ -0,0 +1,40 @@
+#include "base/net/impl/net_thread.h"
+
+#include "base/logging.h"
+#include "base/net/impl/net_thread_impl.h"
+
+namespace base {
+namespace net {
+
+// static
+NetThread& NetThread::GetInstance() {
+  static NetThread instance;
+  return instance;
+}
+
+void NetThread::Start() {
+  DCHECK(!impl_);
+
+  impl_ = std::make_unique<NetThreadImpl>();
+  impl_->Start();
+}
+
+void NetThread::Stop() {
+  DCHECK(impl_);
+
+  impl_->Stop();
+  impl_.reset();
+}
+
+void NetThread::EnqueueDownload(
+    ResourceRequest request,
+    std::optional<size_t> max_response_size_bytes,
+    OnceCallback<void(ResourceResponse)> on_done_callback) {
+  DCHECK(impl_);
+
+  impl_->EnqueueDownload(std::move(request), std::move(max_response_size_bytes),
+                         std::move(on_done_callback));
+}
+
+}  // namespace net
+}  // namespace base

src/base/net/impl/net_thread.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+
+#include "base/callback.h"
+#include "base/net/resource_request.h"
+#include "base/net/resource_response.h"
+
+namespace base {
+namespace net {
+
+class NetThread {
+ public:
+  static NetThread& GetInstance();
+
+  void Start();
+  void Stop();
+
+  void EnqueueDownload(ResourceRequest request,
+                       std::optional<size_t> max_response_size_bytes,
+                       OnceCallback<void(ResourceResponse)> on_done_callback);
+
+ private:
+  class NetThreadImpl;
+
+  std::unique_ptr<NetThreadImpl> impl_;
+};
+
+}  // namespace net
+}  // namespace base