diff --git a/Android.bp b/Android.bp
index 89dea90..962a9a7 100644
--- a/Android.bp
+++ b/Android.bp
@@ -80,6 +80,9 @@
             cflags: [
                 "-DUSE_FEC=1",
             ],
+            shared_libs: [
+                "libbase",
+            ],
         },
         host: {
             cflags: [
diff --git a/aosp/dynamic_partition_control_android.cc b/aosp/dynamic_partition_control_android.cc
index af46b35..822b05e 100644
--- a/aosp/dynamic_partition_control_android.cc
+++ b/aosp/dynamic_partition_control_android.cc
@@ -32,7 +32,7 @@
 #include <base/files/file_util.h>
 #include <base/logging.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <bootloader_message/bootloader_message.h>
 #include <fs_mgr.h>
 #include <fs_mgr_dm_linear.h>
@@ -57,6 +57,7 @@
 using android::base::GetBoolProperty;
 using android::base::GetProperty;
 using android::base::Join;
+using android::base::StringPrintf;
 using android::dm::DeviceMapper;
 using android::dm::DmDeviceState;
 using android::fs_mgr::CreateLogicalPartition;
@@ -72,7 +73,6 @@
 using android::snapshot::SnapshotManager;
 using android::snapshot::SnapshotManagerStub;
 using android::snapshot::UpdateState;
-using base::StringPrintf;
 
 namespace chromeos_update_engine {
 
@@ -943,7 +943,8 @@
     }
     case SpaceLimit::ERROR_IF_EXCEEDED_SUPER: {
       if (sum_groups > full_space) {
-        LOG(ERROR) << base::StringPrintf(fmt, sum_groups, "", full_space);
+        LOG(ERROR) << android::base::StringPrintf(
+            fmt, sum_groups, "", full_space);
         return false;
       }
       break;
diff --git a/aosp/logging_android.cc b/aosp/logging_android.cc
index 1a0fa9a..d1f10d6 100644
--- a/aosp/logging_android.cc
+++ b/aosp/logging_android.cc
@@ -33,7 +33,7 @@
 #include <base/files/dir_reader_posix.h>
 #include <base/logging.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <log/log.h>
 
 #include "android/log.h"
@@ -93,9 +93,10 @@
 string SetupLogFile(const string& kLogsRoot) {
   DeleteOldLogs(kLogsRoot);
 
-  return base::StringPrintf("%s/update_engine.%s",
-                            kLogsRoot.c_str(),
-                            utils::GetTimeAsString(::time(nullptr)).c_str());
+  return android::base::StringPrintf(
+      "%s/update_engine.%s",
+      kLogsRoot.c_str(),
+      utils::GetTimeAsString(::time(nullptr)).c_str());
 }
 
 const char* LogPriorityToCString(int priority) {
diff --git a/aosp/sideload_main.cc b/aosp/sideload_main.cc
index bf015c9..4a92ca7 100644
--- a/aosp/sideload_main.cc
+++ b/aosp/sideload_main.cc
@@ -21,7 +21,7 @@
 
 #include <base/command_line.h>
 #include <base/strings/string_split.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <brillo/asynchronous_signal_handler.h>
 #include <brillo/flag_helper.h>
 #include <brillo/message_loops/base_message_loop.h>
@@ -73,12 +73,12 @@
                               status == UpdateStatus::FINALIZING)) {
       // Split the progress bar in two parts for the two stages DOWNLOADING and
       // FINALIZING.
-      ReportStatus(base::StringPrintf(
+      ReportStatus(android::base::StringPrintf(
           "ui_print Step %d/2", status == UpdateStatus::DOWNLOADING ? 1 : 2));
-      ReportStatus(base::StringPrintf("progress 0.5 0"));
+      ReportStatus(android::base::StringPrintf("progress 0.5 0"));
     }
     if (status_ != status || fabs(progress - progress_) > 0.005) {
-      ReportStatus(base::StringPrintf("set_progress %.lf", progress));
+      ReportStatus(android::base::StringPrintf("set_progress %.lf", progress));
     }
     progress_ = progress;
     status_ = status;
@@ -86,10 +86,10 @@
 
   void SendPayloadApplicationComplete(ErrorCode error_code) override {
     if (error_code != ErrorCode::kSuccess) {
-      ReportStatus(
-          base::StringPrintf("ui_print Error applying update: %d (%s)",
-                             error_code,
-                             utils::ErrorCodeToString(error_code).c_str()));
+      ReportStatus(android::base::StringPrintf(
+          "ui_print Error applying update: %d (%s)",
+          error_code,
+          utils::ErrorCodeToString(error_code).c_str()));
     }
     error_code_ = error_code;
     brillo::MessageLoop::current()->BreakLoop();
diff --git a/aosp/update_attempter_android.cc b/aosp/update_attempter_android.cc
index 857685f..6b05603 100644
--- a/aosp/update_attempter_android.cc
+++ b/aosp/update_attempter_android.cc
@@ -24,11 +24,11 @@
 #include <vector>
 
 #include <android-base/parsebool.h>
+#include <android-base/parseint.h>
 #include <android-base/properties.h>
 #include <android-base/unique_fd.h>
 #include <base/bind.h>
 #include <base/logging.h>
-#include <base/strings/string_number_conversions.h>
 #include <brillo/data_encoding.h>
 #include <brillo/message_loops/message_loop.h>
 #include <brillo/strings/string_utils.h>
@@ -113,7 +113,7 @@
 
 bool GetHeaderAsBool(const string& header, bool default_value) {
   int value = 0;
-  if (base::StringToInt(header, &value) && (value == 0 || value == 1))
+  if (android::base::ParseInt(header, &value) && (value == 0 || value == 1))
     return value == 1;
   return default_value;
 }
@@ -274,8 +274,8 @@
   InstallPlan::Payload payload;
   payload.size = payload_size;
   if (!payload.size) {
-    if (!base::StringToUint64(headers[kPayloadPropertyFileSize],
-                              &payload.size)) {
+    if (!android::base::ParseUint<uint64_t>(headers[kPayloadPropertyFileSize],
+                                            &payload.size)) {
       payload.size = 0;
     }
   }
@@ -284,8 +284,8 @@
     LOG(WARNING) << "Unable to decode base64 file hash: "
                  << headers[kPayloadPropertyFileHash];
   }
-  if (!base::StringToUint64(headers[kPayloadPropertyMetadataSize],
-                            &payload.metadata_size)) {
+  if (!android::base::ParseUint<uint64_t>(headers[kPayloadPropertyMetadataSize],
+                                          &payload.metadata_size)) {
     payload.metadata_size = 0;
   }
   // The |payload.type| is not used anymore since minor_version 3.
@@ -340,8 +340,8 @@
 
   NetworkId network_id = kDefaultNetworkId;
   if (!headers[kPayloadPropertyNetworkId].empty()) {
-    if (!base::StringToUint64(headers[kPayloadPropertyNetworkId],
-                              &network_id)) {
+    if (!android::base::ParseUint<uint64_t>(headers[kPayloadPropertyNetworkId],
+                                            &network_id)) {
       return LogAndSetGenericError(
           error,
           __LINE__,
diff --git a/certificate_checker.cc b/certificate_checker.cc
index 938c66f..d1dae83 100644
--- a/certificate_checker.cc
+++ b/certificate_checker.cc
@@ -21,7 +21,7 @@
 #include <base/logging.h>
 #include <base/strings/string_number_conversions.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <curl/curl.h>
 #include <openssl/evp.h>
 #include <openssl/ssl.h>
@@ -160,10 +160,11 @@
   // prefs.
   string digest_string = base::HexEncode(digest, digest_length);
 
-  string storage_key = base::StringPrintf("%s-%d-%d",
-                                          kPrefsUpdateServerCertificate,
-                                          static_cast<int>(server_to_check),
-                                          depth);
+  string storage_key =
+      android::base::StringPrintf("%s-%d-%d",
+                                  kPrefsUpdateServerCertificate,
+                                  static_cast<int>(server_to_check),
+                                  depth);
   string stored_digest;
   // If there's no stored certificate, we just store the current one and return.
   if (!prefs_->GetString(storage_key, &stored_digest)) {
diff --git a/certificate_checker_unittest.cc b/certificate_checker_unittest.cc
index 15d6555..01dddbe 100644
--- a/certificate_checker_unittest.cc
+++ b/certificate_checker_unittest.cc
@@ -19,7 +19,7 @@
 #include <string>
 
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
@@ -46,10 +46,10 @@
 class CertificateCheckerTest : public testing::Test {
  protected:
   void SetUp() override {
-    cert_key_ = base::StringPrintf("%s-%d-%d",
-                                   cert_key_prefix_.c_str(),
-                                   static_cast<int>(server_to_check_),
-                                   depth_);
+    cert_key_ = android::base::StringPrintf("%s-%d-%d",
+                                            cert_key_prefix_.c_str(),
+                                            static_cast<int>(server_to_check_),
+                                            depth_);
     cert_checker.Init();
     cert_checker.SetObserver(&observer_);
   }
diff --git a/common/file_fetcher.cc b/common/file_fetcher.cc
index 7134fd6..dd994ab 100644
--- a/common/file_fetcher.cc
+++ b/common/file_fetcher.cc
@@ -24,7 +24,7 @@
 #include <base/location.h>
 #include <base/logging.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <brillo/streams/file_stream.h>
 
 #include "update_engine/common/hardware_interface.h"
diff --git a/common/http_fetcher_unittest.cc b/common/http_fetcher_unittest.cc
index d5b319a..ac03729 100644
--- a/common/http_fetcher_unittest.cc
+++ b/common/http_fetcher_unittest.cc
@@ -35,7 +35,7 @@
 #include <base/stl_util.h>
 #include <base/strings/string_number_conversions.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #if BASE_VER >= 780000  // CrOS
 #include <base/task/single_thread_task_executor.h>
 #endif  // BASE_VER >= 780000
@@ -88,8 +88,8 @@
 static const char* kUnusedUrl = "unused://unused";
 
 static inline string LocalServerUrlForPath(in_port_t port, const string& path) {
-  string port_str = (port ? base::StringPrintf(":%hu", port) : "");
-  return base::StringPrintf(
+  string port_str = (port ? android::base::StringPrintf(":%hu", port) : "");
+  return android::base::StringPrintf(
       "http://127.0.0.1%s%s", port_str.c_str(), path.c_str());
 }
 
@@ -272,7 +272,7 @@
 
   string BigUrl(in_port_t port) const override {
     return LocalServerUrlForPath(
-        port, base::StringPrintf("/download/%d", kBigLength));
+        port, android::base::StringPrintf("/download/%d", kBigLength));
   }
   string SmallUrl(in_port_t port) const override {
     return LocalServerUrlForPath(port, "/foo");
@@ -768,16 +768,17 @@
     unique_ptr<HttpServer> server(this->test_.CreateServer());
     ASSERT_TRUE(server->started_);
 
-    this->loop_.PostTask(FROM_HERE,
-                         base::Bind(&StartTransfer,
-                                    fetcher.get(),
-                                    LocalServerUrlForPath(
-                                        server->GetPort(),
-                                        base::StringPrintf("/flaky/%d/%d/%d/%d",
-                                                           kBigLength,
-                                                           kFlakyTruncateLength,
-                                                           kFlakySleepEvery,
-                                                           kFlakySleepSecs))));
+    this->loop_.PostTask(
+        FROM_HERE,
+        base::Bind(&StartTransfer,
+                   fetcher.get(),
+                   LocalServerUrlForPath(
+                       server->GetPort(),
+                       android::base::StringPrintf("/flaky/%d/%d/%d/%d",
+                                                   kBigLength,
+                                                   kFlakyTruncateLength,
+                                                   kFlakySleepEvery,
+                                                   kFlakySleepSecs))));
     this->loop_.Run();
 
     // verify the data we get back
@@ -908,12 +909,13 @@
       FROM_HERE,
       base::Bind(StartTransfer,
                  fetcher.get(),
-                 LocalServerUrlForPath(port,
-                                       base::StringPrintf("/flaky/%d/%d/%d/%d",
-                                                          kBigLength,
-                                                          kFlakyTruncateLength,
-                                                          kFlakySleepEvery,
-                                                          kFlakySleepSecs))));
+                 LocalServerUrlForPath(
+                     port,
+                     android::base::StringPrintf("/flaky/%d/%d/%d/%d",
+                                                 kBigLength,
+                                                 kFlakyTruncateLength,
+                                                 kFlakySleepEvery,
+                                                 kFlakySleepSecs))));
   this->loop_.Run();
   EXPECT_EQ(1, delegate.times_transfer_complete_called_);
   EXPECT_EQ(0, delegate.times_transfer_terminated_called_);
@@ -940,12 +942,13 @@
       FROM_HERE,
       base::Bind(StartTransfer,
                  fetcher.get(),
-                 LocalServerUrlForPath(port,
-                                       base::StringPrintf("/flaky/%d/%d/%d/%d",
-                                                          kBigLength,
-                                                          kFlakyTruncateLength,
-                                                          kFlakySleepEvery,
-                                                          kFlakySleepSecs))));
+                 LocalServerUrlForPath(
+                     port,
+                     android::base::StringPrintf("/flaky/%d/%d/%d/%d",
+                                                 kBigLength,
+                                                 kFlakyTruncateLength,
+                                                 kFlakySleepEvery,
+                                                 kFlakySleepSecs))));
   // Terminating the transfer after 3 seconds gives it a chance to contact the
   // server and enter the retry loop.
   this->loop_.PostDelayedTask(FROM_HERE,
@@ -1031,8 +1034,8 @@
   unique_ptr<HttpServer> server(this->test_.CreateServer());
   ASSERT_TRUE(server->started_);
 
-  for (size_t c = 0; c < std::size(kRedirectCodes); ++c) {
-    const string url = base::StringPrintf(
+  for (size_t c = 0; c < base::size(kRedirectCodes); ++c) {
+    const string url = android::base::StringPrintf(
         "/redirect/%d/download/%d", kRedirectCodes[c], kMediumLength);
     RedirectTest(server.get(), true, url, this->test_.NewLargeFetcher());
   }
@@ -1047,10 +1050,10 @@
 
   string url;
   for (int r = 0; r < kDownloadMaxRedirects; r++) {
-    url += base::StringPrintf("/redirect/%d",
-                              kRedirectCodes[r % std::size(kRedirectCodes)]);
+    url += android::base::StringPrintf(
+        "/redirect/%d", kRedirectCodes[r % base::size(kRedirectCodes)]);
   }
-  url += base::StringPrintf("/download/%d", kMediumLength);
+  url += android::base::StringPrintf("/download/%d", kMediumLength);
   RedirectTest(server.get(), true, url, this->test_.NewLargeFetcher());
 }
 
@@ -1063,10 +1066,10 @@
 
   string url;
   for (int r = 0; r < kDownloadMaxRedirects + 1; r++) {
-    url += base::StringPrintf("/redirect/%d",
-                              kRedirectCodes[r % std::size(kRedirectCodes)]);
+    url += android::base::StringPrintf(
+        "/redirect/%d", kRedirectCodes[r % base::size(kRedirectCodes)]);
   }
-  url += base::StringPrintf("/download/%d", kMediumLength);
+  url += android::base::StringPrintf("/download/%d", kMediumLength);
   RedirectTest(server.get(), false, url, this->test_.NewLargeFetcher());
 }
 
@@ -1118,7 +1121,7 @@
                                                   e = ranges.end();
        it != e;
        ++it) {
-    string tmp_str = base::StringPrintf("%jd+", it->first);
+    string tmp_str = android::base::StringPrintf("%jd+", it->first);
     if (it->second > 0) {
       base::StringAppendF(&tmp_str, "%jd", it->second);
       multi_fetcher->AddRange(it->first, it->second);
@@ -1256,9 +1259,9 @@
   ranges.push_back(make_pair(99, 0));
   MultiTest(this->test_.NewLargeFetcher(3),
             this->test_.fake_hardware(),
-            LocalServerUrlForPath(
-                server->GetPort(),
-                base::StringPrintf("/error-if-offset/%d/2", kBigLength)),
+            LocalServerUrlForPath(server->GetPort(),
+                                  android::base::StringPrintf(
+                                      "/error-if-offset/%d/2", kBigLength)),
             ranges,
             "abcdefghijabcdefghijabcdejabcdefghijabcdef",
             kBigLength - (99 - 25),
@@ -1279,9 +1282,9 @@
   ranges.push_back(make_pair(99, 0));
   MultiTest(this->test_.NewLargeFetcher(),
             this->test_.fake_hardware(),
-            LocalServerUrlForPath(
-                server->GetPort(),
-                base::StringPrintf("/error-if-offset/%d/3", kBigLength)),
+            LocalServerUrlForPath(server->GetPort(),
+                                  android::base::StringPrintf(
+                                      "/error-if-offset/%d/3", kBigLength)),
             ranges,
             "abcdefghijabcdefghijabcde",  // only received the first chunk
             25,
diff --git a/common/multi_range_http_fetcher.cc b/common/multi_range_http_fetcher.cc
index b5bf923..a7d339b 100644
--- a/common/multi_range_http_fetcher.cc
+++ b/common/multi_range_http_fetcher.cc
@@ -16,7 +16,7 @@
 
 #include "update_engine/common/multi_range_http_fetcher.h"
 
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 
 #include <algorithm>
 #include <string>
@@ -183,7 +183,7 @@
 }
 
 std::string MultiRangeHttpFetcher::Range::ToString() const {
-  std::string range_str = base::StringPrintf("%jd+", offset());
+  std::string range_str = android::base::StringPrintf("%jd+", offset());
   if (HasLength())
     range_str += std::to_string(length());
   else
diff --git a/common/prefs.cc b/common/prefs.cc
index 77078cf..8a727ae 100644
--- a/common/prefs.cc
+++ b/common/prefs.cc
@@ -21,6 +21,7 @@
 #include <unistd.h>
 
 #include <android-base/file.h>
+#include <android-base/parseint.h>
 #include <base/files/file_enumerator.h>
 #include <base/files/file_util.h>
 #include <base/logging.h>
@@ -79,7 +80,7 @@
                << ", got an empty value after trim";
     return false;
   }
-  if (!base::StringToInt64(str_value, value)) {
+  if (!android::base::ParseInt<int64_t>(str_value, value)) {
     LOG(ERROR) << "When reading pref " << key << ", failed to convert value "
                << str_value << " to integer";
     return false;
diff --git a/common/prefs_unittest.cc b/common/prefs_unittest.cc
index 77c746d..3cb04c7 100644
--- a/common/prefs_unittest.cc
+++ b/common/prefs_unittest.cc
@@ -26,7 +26,7 @@
 #include <base/files/scoped_temp_dir.h>
 #include <android-base/macros.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
@@ -282,18 +282,18 @@
 }
 
 TEST_F(PrefsTest, GetInt64Max) {
-  ASSERT_TRUE(SetValue(
-      kKey,
-      base::StringPrintf("%" PRIi64, std::numeric_limits<int64_t>::max())));
+  ASSERT_TRUE(SetValue(kKey,
+                       android::base::StringPrintf(
+                           "%" PRIi64, std::numeric_limits<int64_t>::max())));
   int64_t value;
   EXPECT_TRUE(prefs_.GetInt64(kKey, &value));
   EXPECT_EQ(std::numeric_limits<int64_t>::max(), value);
 }
 
 TEST_F(PrefsTest, GetInt64Min) {
-  ASSERT_TRUE(SetValue(
-      kKey,
-      base::StringPrintf("%" PRIi64, std::numeric_limits<int64_t>::min())));
+  ASSERT_TRUE(SetValue(kKey,
+                       android::base::StringPrintf(
+                           "%" PRIi64, std::numeric_limits<int64_t>::min())));
   int64_t value;
   EXPECT_TRUE(prefs_.GetInt64(kKey, &value));
   EXPECT_EQ(std::numeric_limits<int64_t>::min(), value);
@@ -328,7 +328,8 @@
   EXPECT_TRUE(prefs_.SetInt64(kKey, std::numeric_limits<int64_t>::max()));
   string value;
   EXPECT_TRUE(base::ReadFileToString(prefs_dir_.Append(kKey), &value));
-  EXPECT_EQ(base::StringPrintf("%" PRIi64, std::numeric_limits<int64_t>::max()),
+  EXPECT_EQ(android::base::StringPrintf("%" PRIi64,
+                                        std::numeric_limits<int64_t>::max()),
             value);
 }
 
@@ -336,7 +337,8 @@
   EXPECT_TRUE(prefs_.SetInt64(kKey, std::numeric_limits<int64_t>::min()));
   string value;
   EXPECT_TRUE(base::ReadFileToString(prefs_dir_.Append(kKey), &value));
-  EXPECT_EQ(base::StringPrintf("%" PRIi64, std::numeric_limits<int64_t>::min()),
+  EXPECT_EQ(android::base::StringPrintf("%" PRIi64,
+                                        std::numeric_limits<int64_t>::min()),
             value);
 }
 
diff --git a/common/subprocess.cc b/common/subprocess.cc
index 03ec22a..44734dc 100644
--- a/common/subprocess.cc
+++ b/common/subprocess.cc
@@ -31,7 +31,7 @@
 #include <base/logging.h>
 #include <base/posix/eintr_wrapper.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <brillo/secure_blob.h>
 
 #include "update_engine/common/utils.h"
diff --git a/common/subprocess_unittest.cc b/common/subprocess_unittest.cc
index 0cb7b37..2328693 100644
--- a/common/subprocess_unittest.cc
+++ b/common/subprocess_unittest.cc
@@ -32,7 +32,7 @@
 #include <base/message_loop/message_loop.h>
 #endif  // BASE_VER < 780000
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #if BASE_VER >= 780000  // Chrome OS
 #include <base/task/single_thread_task_executor.h>
 #endif  // BASE_VER >= 780000
@@ -247,7 +247,7 @@
   vector<string> cmd = {
       kBinPath "/sh",
       "-c",
-      base::StringPrintf(
+      android::base::StringPrintf(
           // The 'sleep' launched below could be left behind as an orphaned
           // process when the 'sh' process is terminated by SIGTERM. As a
           // remedy, trap SIGTERM and kill the 'sleep' process, which requires
diff --git a/common/utils.cc b/common/utils.cc
index 53ef8d0..191e95a 100644
--- a/common/utils.cc
+++ b/common/utils.cc
@@ -52,7 +52,7 @@
 #include <base/strings/string_number_conversions.h>
 #include <base/strings/string_split.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <brillo/data_encoding.h>
 
 #include "update_engine/common/constants.h"
@@ -913,13 +913,13 @@
 string ToString(const Time utc_time) {
   Time::Exploded exp_time{};
   utc_time.UTCExplode(&exp_time);
-  return base::StringPrintf("%d/%d/%d %d:%02d:%02d GMT",
-                            exp_time.month,
-                            exp_time.day_of_month,
-                            exp_time.year,
-                            exp_time.hour,
-                            exp_time.minute,
-                            exp_time.second);
+  return android::base::StringPrintf("%d/%d/%d %d:%02d:%02d GMT",
+                                     exp_time.month,
+                                     exp_time.day_of_month,
+                                     exp_time.year,
+                                     exp_time.hour,
+                                     exp_time.minute,
+                                     exp_time.second);
 }
 
 string ToString(bool b) {
@@ -1005,9 +1005,9 @@
                           size_t payload_size) {
   string encoded_hash = brillo::data_encoding::Base64Encode(
       brillo::data_encoding::Base64Encode(payload_hash));
-  return base::StringPrintf("cros_update_size_%" PRIuS "_hash_%s",
-                            payload_size,
-                            encoded_hash.c_str());
+  return android::base::StringPrintf("cros_update_size_%" PRIuS "_hash_%s",
+                                     payload_size,
+                                     encoded_hash.c_str());
 }
 
 bool ConvertToOmahaInstallDate(Time time, int* out_num_days) {
diff --git a/download_action.cc b/download_action.cc
index 566fad9..9a8c870 100644
--- a/download_action.cc
+++ b/download_action.cc
@@ -16,14 +16,11 @@
 
 #include "update_engine/common/download_action.h"
 
-#include <errno.h>
-
-#include <algorithm>
 #include <string>
 
 #include <base/files/file_path.h>
 #include <base/metrics/statistics_recorder.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 
 #include "update_engine/common/boot_control_interface.h"
 #include "update_engine/common/error_code_utils.h"
diff --git a/libcurl_http_fetcher.cc b/libcurl_http_fetcher.cc
index 2e5a520..0ffb60b 100644
--- a/libcurl_http_fetcher.cc
+++ b/libcurl_http_fetcher.cc
@@ -30,7 +30,7 @@
 #include <base/logging.h>
 #include <base/strings/string_split.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <base/threading/thread_task_runner_handle.h>
 
 #ifdef __ANDROID__
@@ -196,7 +196,7 @@
   if (post_data_set_) {
     // Set the Content-Type HTTP header, if one was specifically set.
     if (post_content_type_ != kHttpContentTypeUnspecified) {
-      const string content_type_attr = base::StringPrintf(
+      const string content_type_attr = android::base::StringPrintf(
           "Content-Type: %s", GetHttpContentTypeString(post_content_type_));
       curl_http_headers_ =
           curl_slist_append(curl_http_headers_, content_type_attr.c_str());
@@ -222,7 +222,7 @@
     }
 
     // Create a string representation of the desired range.
-    string range_str = base::StringPrintf(
+    string range_str = android::base::StringPrintf(
         "%" PRIu64 "-", static_cast<uint64_t>(resume_offset_));
     if (end_offset)
       range_str += std::to_string(end_offset);
diff --git a/lz4diff/lz4diff_compress_unittest.cc b/lz4diff/lz4diff_compress_unittest.cc
index 9caa9a3..0a2b117 100644
--- a/lz4diff/lz4diff_compress_unittest.cc
+++ b/lz4diff/lz4diff_compress_unittest.cc
@@ -21,11 +21,10 @@
 #include <string>
 #include <vector>
 
-#include <base/format_macros.h>
 #include <base/logging.h>
 #include <base/strings/string_number_conversions.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <gtest/gtest.h>
 #include <erofs/internal.h>
 #include <erofs/io.h>
@@ -35,7 +34,6 @@
 #include "update_engine/lz4diff/lz4diff_compress.h"
 #include "update_engine/payload_generator/delta_diff_generator.h"
 #include "update_engine/payload_generator/erofs_filesystem.h"
-#include "update_engine/payload_generator/extent_utils.h"
 
 using std::string;
 using std::vector;
diff --git a/lz4diff/lz4diff_unittest.cc b/lz4diff/lz4diff_unittest.cc
index aabff99..b64a36a 100644
--- a/lz4diff/lz4diff_unittest.cc
+++ b/lz4diff/lz4diff_unittest.cc
@@ -25,7 +25,7 @@
 #include <base/logging.h>
 #include <base/strings/string_number_conversions.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <gtest/gtest.h>
 #include <erofs/internal.h>
 #include <erofs/io.h>
diff --git a/payload_consumer/delta_performer.cc b/payload_consumer/delta_performer.cc
index 519ec71..0b4a13e 100644
--- a/payload_consumer/delta_performer.cc
+++ b/payload_consumer/delta_performer.cc
@@ -33,7 +33,7 @@
 #include <base/format_macros.h>
 #include <base/metrics/histogram_macros.h>
 #include <base/strings/string_number_conversions.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <base/time/time.h>
 #include <brillo/data_encoding.h>
 #include <bsdiff/bspatch.h>
@@ -89,7 +89,7 @@
   if (num_total_operations_) {
     total_operations_str = std::to_string(num_total_operations_);
     // Upcasting to 64-bit to avoid overflow, back to size_t for formatting.
-    completed_percentage_str = base::StringPrintf(
+    completed_percentage_str = android::base::StringPrintf(
         " (%" PRIu64 "%%)",
         IntRatio(next_operation_num_, num_total_operations_, 100));
   }
@@ -101,7 +101,7 @@
   if (payload_size) {
     payload_size_str = std::to_string(payload_size);
     // Upcasting to 64-bit to avoid overflow, back to size_t for formatting.
-    downloaded_percentage_str = base::StringPrintf(
+    downloaded_percentage_str = android::base::StringPrintf(
         " (%" PRIu64 "%%)", IntRatio(total_bytes_received_, payload_size, 100));
   }
 
@@ -998,7 +998,8 @@
     uint64_t this_length =
         min(full_length - length,
             static_cast<uint64_t>(extent.num_blocks()) * block_size);
-    ret += base::StringPrintf("%" PRIi64 ":%" PRIu64 ",", start, this_length);
+    ret += android::base::StringPrintf(
+        "%" PRIi64 ":%" PRIu64 ",", start, this_length);
     length += this_length;
   }
   TEST_AND_RETURN_FALSE(length == full_length);
diff --git a/payload_consumer/delta_performer_integration_test.cc b/payload_consumer/delta_performer_integration_test.cc
index ffc753a..3dfd12a 100644
--- a/payload_consumer/delta_performer_integration_test.cc
+++ b/payload_consumer/delta_performer_integration_test.cc
@@ -16,7 +16,6 @@
 
 #include "update_engine/payload_consumer/delta_performer.h"
 
-#include <inttypes.h>
 #include <sys/mount.h>
 
 #include <algorithm>
@@ -27,7 +26,7 @@
 #include <base/files/file_path.h>
 #include <base/files/file_util.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <gmock/gmock-matchers.h>
 #include <google/protobuf/repeated_field.h>
 #include <gtest/gtest.h>
@@ -37,7 +36,6 @@
 #include "update_engine/common/fake_boot_control.h"
 #include "update_engine/common/fake_hardware.h"
 #include "update_engine/common/fake_prefs.h"
-#include "update_engine/common/hardware_interface.h"
 #include "update_engine/common/mock_download_action.h"
 #include "update_engine/common/mock_prefs.h"
 #include "update_engine/common/test_utils.h"
@@ -251,14 +249,15 @@
     size_t signature_size{};
     ASSERT_TRUE(
         PayloadSigner::GetMaximumSignatureSize(key_path, &signature_size));
-    signature_size_strings.push_back(base::StringPrintf("%zu", signature_size));
+    signature_size_strings.push_back(
+        android::base::StringPrintf("%zu", signature_size));
   }
   string signature_size_string = base::JoinString(signature_size_strings, ":");
 
   ScopedTempFile hash_file("hash.XXXXXX"), metadata_hash_file("hash.XXXXXX");
   string delta_generator_path = GetBuildArtifactsPath("delta_generator");
   ASSERT_EQ(0,
-            System(base::StringPrintf(
+            System(android::base::StringPrintf(
                 "%s -in_file=%s -signature_size=%s -out_hash_file=%s "
                 "-out_metadata_hash_file=%s",
                 delta_generator_path.c_str(),
@@ -295,22 +294,24 @@
       base::JoinString(metadata_sig_file_paths, ":");
 
   // Add the signature to the payload.
-  ASSERT_EQ(0,
-            System(base::StringPrintf("%s --signature_size=%s -in_file=%s "
-                                      "-payload_signature_file=%s "
-                                      "-metadata_signature_file=%s "
-                                      "-out_file=%s",
-                                      delta_generator_path.c_str(),
-                                      signature_size_string.c_str(),
-                                      payload_path.c_str(),
-                                      sig_files_string.c_str(),
-                                      metadata_sig_files_string.c_str(),
-                                      payload_path.c_str())));
+  ASSERT_EQ(
+      0,
+      System(android::base::StringPrintf("%s --signature_size=%s -in_file=%s "
+                                         "-payload_signature_file=%s "
+                                         "-metadata_signature_file=%s "
+                                         "-out_file=%s",
+                                         delta_generator_path.c_str(),
+                                         signature_size_string.c_str(),
+                                         payload_path.c_str(),
+                                         sig_files_string.c_str(),
+                                         metadata_sig_files_string.c_str(),
+                                         payload_path.c_str())));
 
-  int verify_result = System(base::StringPrintf("%s -in_file=%s -public_key=%s",
-                                                delta_generator_path.c_str(),
-                                                payload_path.c_str(),
-                                                public_key_path.c_str()));
+  int verify_result =
+      System(android::base::StringPrintf("%s -in_file=%s -public_key=%s",
+                                         delta_generator_path.c_str(),
+                                         payload_path.c_str(),
+                                         public_key_path.c_str()));
 
   if (verification_success) {
     ASSERT_EQ(0, verify_result);
@@ -415,30 +416,32 @@
                             std::end(kRandomString));
     }
     ASSERT_TRUE(utils::WriteFile(
-        base::StringPrintf("%s/hardtocompress", a_mnt.c_str()).c_str(),
+        android::base::StringPrintf("%s/hardtocompress", a_mnt.c_str()).c_str(),
         hardtocompress.data(),
         hardtocompress.size()));
 
     brillo::Blob zeros(16 * 1024, 0);
     ASSERT_EQ(static_cast<int>(zeros.size()),
-              base::WriteFile(base::FilePath(base::StringPrintf(
+              base::WriteFile(base::FilePath(android::base::StringPrintf(
                                   "%s/move-to-sparse", a_mnt.c_str())),
                               reinterpret_cast<const char*>(zeros.data()),
                               zeros.size()));
 
     ASSERT_TRUE(WriteSparseFile(
-        base::StringPrintf("%s/move-from-sparse", a_mnt.c_str()), 16 * 1024));
+        android::base::StringPrintf("%s/move-from-sparse", a_mnt.c_str()),
+        16 * 1024));
 
     ASSERT_TRUE(WriteByteAtOffset(
-        base::StringPrintf("%s/move-semi-sparse", a_mnt.c_str()), 4096));
+        android::base::StringPrintf("%s/move-semi-sparse", a_mnt.c_str()),
+        4096));
 
     // Write 1 MiB of 0xff to try to catch the case where writing a bsdiff
     // patch fails to zero out the final block.
     brillo::Blob ones(1024 * 1024, 0xff);
-    ASSERT_TRUE(
-        utils::WriteFile(base::StringPrintf("%s/ones", a_mnt.c_str()).c_str(),
-                         ones.data(),
-                         ones.size()));
+    ASSERT_TRUE(utils::WriteFile(
+        android::base::StringPrintf("%s/ones", a_mnt.c_str()).c_str(),
+        ones.data(),
+        ones.size()));
   }
 
   // Create a result image with image_size bytes of garbage.
@@ -505,7 +508,7 @@
                             std::end(kRandomString));
     }
     ASSERT_TRUE(utils::WriteFile(
-        base::StringPrintf("%s/hardtocompress", b_mnt.c_str()).c_str(),
+        android::base::StringPrintf("%s/hardtocompress", b_mnt.c_str()).c_str(),
         hardtocompress.data(),
         hardtocompress.size()));
   }
@@ -904,12 +907,11 @@
     // no need to verify new partition if VerifyPayload failed.
     return;
   }
-
-  CompareFilesByBlock(state->result_kernel->path(),
-                      state->new_kernel->path(),
-                      state->kernel_size);
-  CompareFilesByBlock(
-      state->result_img->path(), state->b_img->path(), state->image_size);
+  ASSERT_NO_FATAL_FAILURE(CompareFilesByBlock(state->result_kernel->path(),
+                                              state->new_kernel->path(),
+                                              state->kernel_size));
+  ASSERT_NO_FATAL_FAILURE(CompareFilesByBlock(
+      state->result_img->path(), state->b_img->path(), state->image_size));
 
   brillo::Blob updated_kernel_partition;
   ASSERT_TRUE(
@@ -955,7 +957,8 @@
       break;  // appease gcc
   }
 
-  VerifyPayloadResult(performer, state, expected_result, minor_version);
+  ASSERT_NO_FATAL_FAILURE(
+      VerifyPayloadResult(performer, state, expected_result, minor_version));
 }
 
 void DoSmallImageTest(bool full_kernel,
@@ -966,22 +969,23 @@
                       uint32_t minor_version) {
   DeltaState state;
   DeltaPerformer* performer = nullptr;
-  GenerateDeltaFile(full_kernel,
-                    full_rootfs,
-                    chunk_size,
-                    signature_test,
-                    &state,
-                    minor_version);
+  ASSERT_NO_FATAL_FAILURE(GenerateDeltaFile(full_kernel,
+                                            full_rootfs,
+                                            chunk_size,
+                                            signature_test,
+                                            &state,
+                                            minor_version));
 
-  ApplyDeltaFile(full_kernel,
-                 full_rootfs,
-                 signature_test,
-                 &state,
-                 hash_checks_mandatory,
-                 kValidOperationData,
-                 &performer,
-                 minor_version);
-  VerifyPayload(performer, &state, signature_test, minor_version);
+  ASSERT_NO_FATAL_FAILURE(ApplyDeltaFile(full_kernel,
+                                         full_rootfs,
+                                         signature_test,
+                                         &state,
+                                         hash_checks_mandatory,
+                                         kValidOperationData,
+                                         &performer,
+                                         minor_version));
+  ASSERT_NO_FATAL_FAILURE(
+      VerifyPayload(performer, &state, signature_test, minor_version));
   delete performer;
 }
 
@@ -991,14 +995,14 @@
   uint64_t minor_version = kFullPayloadMinorVersion;
   GenerateDeltaFile(true, true, -1, kSignatureGenerated, &state, minor_version);
   DeltaPerformer* performer = nullptr;
-  ApplyDeltaFile(true,
-                 true,
-                 kSignatureGenerated,
-                 &state,
-                 hash_checks_mandatory,
-                 op_hash_test,
-                 &performer,
-                 minor_version);
+  ASSERT_NO_FATAL_FAILURE(ApplyDeltaFile(true,
+                                         true,
+                                         kSignatureGenerated,
+                                         &state,
+                                         hash_checks_mandatory,
+                                         op_hash_test,
+                                         &performer,
+                                         minor_version));
   delete performer;
 }
 
diff --git a/payload_consumer/delta_performer_unittest.cc b/payload_consumer/delta_performer_unittest.cc
index 443bef6..0e29ddf 100644
--- a/payload_consumer/delta_performer_unittest.cc
+++ b/payload_consumer/delta_performer_unittest.cc
@@ -25,12 +25,12 @@
 #include <string>
 #include <vector>
 
+#include <android-base/parseint.h>
 #include <base/files/file_path.h>
 #include <base/files/file_util.h>
 #include <base/files/scoped_temp_dir.h>
-#include <base/strings/string_number_conversions.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <brillo/secure_blob.h>
 #include <gmock/gmock.h>
 #include <google/protobuf/repeated_field.h>
@@ -1078,7 +1078,8 @@
   string major_version_str;
   uint64_t major_version{};
   EXPECT_TRUE(store.GetString("PAYLOAD_MAJOR_VERSION", &major_version_str));
-  EXPECT_TRUE(base::StringToUint64(major_version_str, &major_version));
+  EXPECT_TRUE(
+      android::base::ParseUint<uint64_t>(major_version_str, &major_version));
   EXPECT_EQ(kMaxSupportedMajorPayloadVersion, major_version);
 }
 
diff --git a/payload_consumer/install_plan.cc b/payload_consumer/install_plan.cc
index 9c3934d..f5cab45 100644
--- a/payload_consumer/install_plan.cc
+++ b/payload_consumer/install_plan.cc
@@ -23,7 +23,7 @@
 #include <base/logging.h>
 #include <base/strings/string_number_conversions.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 
 #include "update_engine/common/utils.h"
 #include "update_engine/update_metadata.pb.h"
diff --git a/payload_consumer/partition_writer.cc b/payload_consumer/partition_writer.cc
index e55722c..a415100 100644
--- a/payload_consumer/partition_writer.cc
+++ b/payload_consumer/partition_writer.cc
@@ -30,7 +30,7 @@
 
 #include <base/strings/string_number_conversions.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 
 #include "update_engine/common/error_code.h"
 #include "update_engine/common/utils.h"
@@ -328,9 +328,9 @@
     vector<string> source_extents;
     for (const Extent& ext : operation.src_extents()) {
       source_extents.push_back(
-          base::StringPrintf("%" PRIu64 ":%" PRIu64,
-                             static_cast<uint64_t>(ext.start_block()),
-                             static_cast<uint64_t>(ext.num_blocks())));
+          android::base::StringPrintf("%" PRIu64 ":%" PRIu64,
+                                      static_cast<uint64_t>(ext.start_block()),
+                                      static_cast<uint64_t>(ext.num_blocks())));
     }
     LOG(ERROR) << "Operation source (offset:size) in blocks: "
                << base::JoinString(source_extents, ",");
diff --git a/payload_consumer/payload_metadata.cc b/payload_consumer/payload_metadata.cc
index f797723..d2e42f0 100644
--- a/payload_consumer/payload_metadata.cc
+++ b/payload_consumer/payload_metadata.cc
@@ -18,7 +18,7 @@
 
 #include <endian.h>
 
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <brillo/data_encoding.h>
 
 #include "update_engine/common/constants.h"
@@ -62,17 +62,17 @@
   // Validate the magic string.
   if (memcmp(payload, kDeltaMagic, sizeof(kDeltaMagic)) != 0) {
     LOG(ERROR) << "Bad payload format -- invalid delta magic: "
-               << base::StringPrintf("%02x%02x%02x%02x",
-                                     payload[0],
-                                     payload[1],
-                                     payload[2],
-                                     payload[3])
+               << android::base::StringPrintf("%02x%02x%02x%02x",
+                                              payload[0],
+                                              payload[1],
+                                              payload[2],
+                                              payload[3])
                << " Expected: "
-               << base::StringPrintf("%02x%02x%02x%02x",
-                                     kDeltaMagic[0],
-                                     kDeltaMagic[1],
-                                     kDeltaMagic[2],
-                                     kDeltaMagic[3]);
+               << android::base::StringPrintf("%02x%02x%02x%02x",
+                                              kDeltaMagic[0],
+                                              kDeltaMagic[1],
+                                              kDeltaMagic[2],
+                                              kDeltaMagic[3]);
     *error = ErrorCode::kDownloadInvalidMetadataMagicString;
     return MetadataParseResult::kError;
   }
diff --git a/payload_consumer/postinstall_runner_action_unittest.cc b/payload_consumer/postinstall_runner_action_unittest.cc
index c899599..38985dc 100644
--- a/payload_consumer/postinstall_runner_action_unittest.cc
+++ b/payload_consumer/postinstall_runner_action_unittest.cc
@@ -30,7 +30,7 @@
 #include <base/message_loop/message_loop.h>
 #endif  // BASE_VER < 780000
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #if BASE_VER >= 780000  // CrOS
 #include <base/task/single_thread_task_executor.h>
 #endif  // BASE_VER >= 780000
@@ -116,7 +116,7 @@
 
   void SuspendRunningAction() {
     if (!postinstall_action_ || !postinstall_action_->current_command_ ||
-        test_utils::Readlink(base::StringPrintf(
+        test_utils::Readlink(android::base::StringPrintf(
             "/proc/%d/fd/0", postinstall_action_->current_command_)) !=
             "/dev/zero") {
       // We need to wait for the postinstall command to start and flag that it
diff --git a/payload_consumer/verified_source_fd.cc b/payload_consumer/verified_source_fd.cc
index d760d1f..ad3a0ef 100644
--- a/payload_consumer/verified_source_fd.cc
+++ b/payload_consumer/verified_source_fd.cc
@@ -24,7 +24,7 @@
 
 #include <base/strings/string_number_conversions.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 
 #include "update_engine/common/error_code.h"
 #include "update_engine/common/hash_calculator.h"
diff --git a/payload_generator/ab_generator.cc b/payload_generator/ab_generator.cc
index c5cd6f3..62d608a 100644
--- a/payload_generator/ab_generator.cc
+++ b/payload_generator/ab_generator.cc
@@ -147,7 +147,8 @@
 
     AnnotatedOperation new_aop;
     new_aop.op = new_op;
-    new_aop.name = android::base::StringPrintf("%s:%d", original_aop.name.c_str(), i);
+    new_aop.name =
+        android::base::StringPrintf("%s:%d", original_aop.name.c_str(), i);
     result_aops->push_back(new_aop);
   }
   if (curr_src_ext_index != original_op.src_extents().size() - 1) {
@@ -183,7 +184,8 @@
 
     AnnotatedOperation new_aop;
     new_aop.op = new_op;
-    new_aop.name = android::base::StringPrintf("%s:%d", original_aop.name.c_str(), i);
+    new_aop.name =
+        android::base::StringPrintf("%s:%d", original_aop.name.c_str(), i);
     TEST_AND_RETURN_FALSE(
         AddDataAndSetType(&new_aop, version, target_part_path, blob_file));
 
diff --git a/payload_generator/annotated_operation.cc b/payload_generator/annotated_operation.cc
index 5637cb1..18924e4 100644
--- a/payload_generator/annotated_operation.cc
+++ b/payload_generator/annotated_operation.cc
@@ -18,7 +18,7 @@
 
 #include <base/format_macros.h>
 #include <base/strings/string_number_conversions.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 
 #include "update_engine/common/utils.h"
 #include "update_engine/payload_consumer/payload_constants.h"
diff --git a/payload_generator/delta_diff_generator.cc b/payload_generator/delta_diff_generator.cc
index 4abff92..eb4e594 100644
--- a/payload_generator/delta_diff_generator.cc
+++ b/payload_generator/delta_diff_generator.cc
@@ -16,9 +16,7 @@
 
 #include "update_engine/payload_generator/delta_diff_generator.h"
 
-#include <errno.h>
 #include <fcntl.h>
-#include <inttypes.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 
@@ -32,9 +30,7 @@
 #include <base/threading/simple_thread.h>
 
 #include "update_engine/common/utils.h"
-#include "update_engine/payload_consumer/delta_performer.h"
 #include "update_engine/payload_consumer/file_descriptor.h"
-#include "update_engine/payload_consumer/payload_constants.h"
 #include "update_engine/payload_generator/ab_generator.h"
 #include "update_engine/payload_generator/annotated_operation.h"
 #include "update_engine/payload_generator/blob_file_writer.h"
@@ -186,8 +182,7 @@
     off_t data_file_size = 0;
     BlobFileWriter blob_file(data_file.fd(), &data_file_size);
     if (config.is_delta) {
-      TEST_AND_RETURN_FALSE(config.source.partitions.size() ==
-                            config.target.partitions.size());
+      TEST_EQ(config.source.partitions.size(), config.target.partitions.size());
     }
     PartitionConfig empty_part("");
     std::vector<std::vector<AnnotatedOperation>> all_aops;
@@ -200,10 +195,18 @@
         config.target.partitions.size());
 
     std::vector<PartitionProcessor> partition_tasks{};
-    auto thread_count = std::min<int>(diff_utils::GetMaxThreads(),
-                                      config.target.partitions.size());
+    auto thread_count = std::min<size_t>(diff_utils::GetMaxThreads(),
+                                         config.target.partitions.size());
+    if (thread_count > config.max_threads && config.max_threads > 0) {
+      thread_count = config.max_threads;
+    }
+    if (thread_count < 1) {
+      thread_count = 1;
+    }
     base::DelegateSimpleThreadPool thread_pool{"partition-thread-pool",
-                                               thread_count};
+                                               static_cast<int>(thread_count)};
+    LOG(INFO) << "Using " << thread_count << " threads to process "
+              << config.target.partitions.size() << " partitions";
     for (size_t i = 0; i < config.target.partitions.size(); i++) {
       const PartitionConfig& old_part =
           config.is_delta ? config.source.partitions[i] : empty_part;
diff --git a/payload_generator/delta_diff_utils.cc b/payload_generator/delta_diff_utils.cc
index 152da4d..549a2b7 100644
--- a/payload_generator/delta_diff_utils.cc
+++ b/payload_generator/delta_diff_utils.cc
@@ -42,7 +42,7 @@
 #include <base/files/file_util.h>
 #include <base/format_macros.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <base/threading/simple_thread.h>
 #include <brillo/data_encoding.h>
 #include <bsdiff/bsdiff.h>
@@ -677,9 +677,12 @@
 
   size_t max_threads = GetMaxThreads();
 
-  if (config.max_threads > 0) {
+  if (config.max_threads > 0 && config.max_threads < max_threads) {
     max_threads = config.max_threads;
   }
+  LOG(INFO) << "Using " << max_threads << " threads to process "
+            << file_delta_processors.size() << " files on partition "
+            << old_part.name;
 
   // Sort the files in descending order based on number of new blocks to make
   // sure we start the largest ones first.
@@ -907,7 +910,7 @@
     }
 
     if (static_cast<uint64_t>(chunk_blocks) < total_blocks) {
-      aop.name = base::StringPrintf(
+      aop.name = android::base::StringPrintf(
           "%s:%" PRIu64, name.c_str(), block_offset / chunk_blocks);
     }
 
@@ -1208,9 +1211,9 @@
   return true;
 }
 
-// Return the number of CPUs on the machine, and 4 threads in minimum.
+// Return the number of CPUs on the machine, and 1 threads in minimum.
 size_t GetMaxThreads() {
-  return std::max(sysconf(_SC_NPROCESSORS_ONLN), 4L);
+  return std::max(sysconf(_SC_NPROCESSORS_ONLN), 1L);
 }
 
 }  // namespace diff_utils
diff --git a/payload_generator/delta_diff_utils_unittest.cc b/payload_generator/delta_diff_utils_unittest.cc
index 53bbeaa..ca6578c 100644
--- a/payload_generator/delta_diff_utils_unittest.cc
+++ b/payload_generator/delta_diff_utils_unittest.cc
@@ -23,7 +23,7 @@
 
 #include <base/files/scoped_file.h>
 #include <base/format_macros.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <bsdiff/patch_writer.h>
 #include <gtest/gtest.h>
 #include <puffin/common.h>
@@ -95,7 +95,7 @@
   size_t num_blocks = part.size / block_size;
   brillo::Blob file_data(part.size);
   for (size_t i = 0; i < num_blocks; ++i) {
-    string prefix = base::StringPrintf(
+    string prefix = android::base::StringPrintf(
         "block tag 0x%.16" PRIx64 ", block number %16" PRIuS " ", tag, i);
     brillo::Blob block_data(prefix.begin(), prefix.end());
     TEST_AND_RETURN_FALSE(prefix.size() <= block_size);
@@ -531,7 +531,8 @@
 
   ASSERT_EQ(expected_op_extents.size(), aops_.size());
   for (size_t i = 0; i < aops_.size() && i < expected_op_extents.size(); ++i) {
-    SCOPED_TRACE(base::StringPrintf("Failed on operation number %" PRIuS, i));
+    SCOPED_TRACE(
+        android::base::StringPrintf("Failed on operation number %" PRIuS, i));
     const AnnotatedOperation& aop = aops_[i];
     ASSERT_EQ(InstallOperation::SOURCE_COPY, aop.op.type());
     ASSERT_EQ(1, aop.op.src_extents_size());
@@ -628,7 +629,8 @@
 
   ASSERT_EQ(expected_op_extents.size(), aops_.size());
   for (size_t i = 0; i < aops_.size() && i < expected_op_extents.size(); ++i) {
-    SCOPED_TRACE(base::StringPrintf("Failed on operation number %" PRIuS, i));
+    SCOPED_TRACE(
+        android::base::StringPrintf("Failed on operation number %" PRIuS, i));
     const AnnotatedOperation& aop = aops_[i];
     ASSERT_EQ(InstallOperation::REPLACE_BZ, aop.op.type());
     ASSERT_EQ(0, aop.op.src_extents_size());
diff --git a/payload_generator/erofs_filesystem_unittest.cc b/payload_generator/erofs_filesystem_unittest.cc
index 58686c3..af7ff5e 100644
--- a/payload_generator/erofs_filesystem_unittest.cc
+++ b/payload_generator/erofs_filesystem_unittest.cc
@@ -25,7 +25,7 @@
 #include <base/logging.h>
 #include <base/strings/string_number_conversions.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <gtest/gtest.h>
 
 #include "payload_generator/delta_diff_generator.h"
diff --git a/payload_generator/ext2_filesystem.cc b/payload_generator/ext2_filesystem.cc
index 535d8ad..062ccfe 100644
--- a/payload_generator/ext2_filesystem.cc
+++ b/payload_generator/ext2_filesystem.cc
@@ -32,7 +32,7 @@
 #include <set>
 
 #include <base/logging.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 
 #include "update_engine/common/utils.h"
 #include "update_engine/payload_generator/extent_ranges.h"
@@ -196,7 +196,7 @@
     if (it_ino == EXT2_RESIZE_INO) {
       file.name = "<group-descriptors>";
     } else {
-      file.name = base::StringPrintf("<inode-%u>", it_ino);
+      file.name = android::base::StringPrintf("<inode-%u>", it_ino);
     }
 
     memset(&file.file_stat, 0, sizeof(file.file_stat));
@@ -266,7 +266,7 @@
       // just skiped.
       LOG(WARNING) << "Reading directory name on inode " << dir_ino
                    << " (error " << error << ")";
-      inodes[dir_ino].name = base::StringPrintf("<dir-%u>", dir_ino);
+      inodes[dir_ino].name = android::base::StringPrintf("<dir-%u>", dir_ino);
     } else {
       inodes[dir_ino].name = dir_name;
       files->push_back(inodes[dir_ino]);
diff --git a/payload_generator/ext2_filesystem_unittest.cc b/payload_generator/ext2_filesystem_unittest.cc
index 4ac7299..2f21718 100644
--- a/payload_generator/ext2_filesystem_unittest.cc
+++ b/payload_generator/ext2_filesystem_unittest.cc
@@ -27,7 +27,7 @@
 #include <base/logging.h>
 #include <base/strings/string_number_conversions.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <gtest/gtest.h>
 
 #include "update_engine/common/test_utils.h"
diff --git a/payload_generator/extent_utils.cc b/payload_generator/extent_utils.cc
index d318fd2..782f95b 100644
--- a/payload_generator/extent_utils.cc
+++ b/payload_generator/extent_utils.cc
@@ -23,8 +23,8 @@
 #include <vector>
 
 #include <base/logging.h>
-#include <android-base/macros.h>
-#include <base/strings/stringprintf.h>
+#include <base/macros.h>
+#include <android-base/stringprintf.h>
 
 #include "update_engine/payload_consumer/payload_constants.h"
 #include "update_engine/payload_generator/extent_ranges.h"
@@ -90,9 +90,10 @@
 string ExtentsToStringTemplate(const Container& extents) {
   string ext_str;
   for (const Extent& e : extents)
-    ext_str += base::StringPrintf("[%" PRIu64 ", %" PRIu64 "] ",
-                                  static_cast<uint64_t>(e.start_block()),
-                                  static_cast<uint64_t>(e.num_blocks()));
+    ext_str +=
+        android::base::StringPrintf("[%" PRIu64 ", %" PRIu64 "] ",
+                                    static_cast<uint64_t>(e.start_block()),
+                                    static_cast<uint64_t>(e.num_blocks()));
   return ext_str;
 }
 
diff --git a/payload_generator/full_update_generator.cc b/payload_generator/full_update_generator.cc
index 4a5f63a..f360642 100644
--- a/payload_generator/full_update_generator.cc
+++ b/payload_generator/full_update_generator.cc
@@ -25,7 +25,7 @@
 
 #include <base/format_macros.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <base/synchronization/lock.h>
 #include <base/threading/simple_thread.h>
 #include <brillo/secure_blob.h>
@@ -164,7 +164,7 @@
     // Preset all the static information about the operations. The
     // ChunkProcessor will set the rest.
     AnnotatedOperation* aop = aops->data() + i;
-    aop->name = base::StringPrintf(
+    aop->name = android::base::StringPrintf(
         "<%s-operation-%" PRIuS ">", new_part.name.c_str(), i);
     Extent* dst_extent = aop->op.add_dst_extents();
     dst_extent->set_start_block(start_block);
diff --git a/payload_generator/generate_delta_main.cc b/payload_generator/generate_delta_main.cc
index 5ffd05e..7507ff3 100644
--- a/payload_generator/generate_delta_main.cc
+++ b/payload_generator/generate_delta_main.cc
@@ -764,7 +764,9 @@
 
   payload_config.security_patch_level = FLAGS_security_patch_level;
 
-  payload_config.max_threads = FLAGS_max_threads;
+  if (FLAGS_max_threads > 0) {
+    payload_config.max_threads = FLAGS_max_threads;
+  }
 
   if (!FLAGS_partition_timestamps.empty()) {
     CHECK(ParsePerPartitionTimestamps(FLAGS_partition_timestamps,
diff --git a/payload_generator/mapfile_filesystem.cc b/payload_generator/mapfile_filesystem.cc
index 5bca577..c9b4cd5 100644
--- a/payload_generator/mapfile_filesystem.cc
+++ b/payload_generator/mapfile_filesystem.cc
@@ -19,10 +19,10 @@
 #include <algorithm>
 #include <map>
 
+#include <android-base/parseint.h>
 #include <base/files/file_util.h>
 #include <base/logging.h>
 #include <base/memory/ptr_util.h>
-#include <base/strings/string_number_conversions.h>
 #include <base/strings/string_split.h>
 
 #include "update_engine/common/utils.h"
@@ -98,11 +98,14 @@
           line.substr(delim + 1, last_delim - (delim + 1)).as_string();
       size_t dash = blocks.find('-', 0);
       uint64_t block_start, block_end;
-      if (dash == string::npos && base::StringToUint64(blocks, &block_start)) {
+      if (dash == string::npos &&
+          android::base::ParseUint<uint64_t>(blocks, &block_start)) {
         mapped_file.extents.push_back(ExtentForRange(block_start, 1));
       } else if (dash != string::npos &&
-                 base::StringToUint64(blocks.substr(0, dash), &block_start) &&
-                 base::StringToUint64(blocks.substr(dash + 1), &block_end)) {
+                 android::base::ParseUint<uint64_t>(blocks.substr(0, dash),
+                                                    &block_start) &&
+                 android::base::ParseUint<uint64_t>(blocks.substr(dash + 1),
+                                                    &block_end)) {
         if (block_end < block_start) {
           LOG(ERROR) << "End block " << block_end
                      << " is smaller than start block " << block_start
diff --git a/payload_generator/mapfile_filesystem_unittest.cc b/payload_generator/mapfile_filesystem_unittest.cc
index 57b672b..567eb80 100644
--- a/payload_generator/mapfile_filesystem_unittest.cc
+++ b/payload_generator/mapfile_filesystem_unittest.cc
@@ -26,7 +26,7 @@
 #include <base/logging.h>
 #include <base/strings/string_number_conversions.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <gtest/gtest.h>
 
 #include "update_engine/common/test_utils.h"
diff --git a/payload_generator/payload_file.cc b/payload_generator/payload_file.cc
index a1734c7..c0362e1 100644
--- a/payload_generator/payload_file.cc
+++ b/payload_generator/payload_file.cc
@@ -18,10 +18,11 @@
 
 #include <endian.h>
 
-#include <algorithm>
 #include <map>
 #include <utility>
 
+#include <android-base/stringprintf.h>
+
 #include "update_engine/common/hash_calculator.h"
 #include "update_engine/common/utils.h"
 #include "update_engine/payload_consumer/file_writer.h"
diff --git a/payload_generator/payload_generation_config.h b/payload_generator/payload_generation_config.h
index 0256a9d..7f107bb 100644
--- a/payload_generator/payload_generation_config.h
+++ b/payload_generator/payload_generation_config.h
@@ -266,7 +266,9 @@
 
   std::string security_patch_level;
 
-  uint32_t max_threads = 0;
+  // This doesn't mean we will use 256 threads, we still upper bound thread
+  // count by number of CPU cores
+  uint32_t max_threads = 256;
 
   std::vector<bsdiff::CompressorType> compressors{
       bsdiff::CompressorType::kBZ2, bsdiff::CompressorType::kBrotli};
diff --git a/payload_generator/payload_generation_config_android.cc b/payload_generator/payload_generation_config_android.cc
index d950092..1abdd55 100644
--- a/payload_generator/payload_generation_config_android.cc
+++ b/payload_generator/payload_generation_config_android.cc
@@ -16,6 +16,7 @@
 
 #include "update_engine/payload_generator/payload_generation_config.h"
 
+#include <android-base/parseint.h>
 #include <base/logging.h>
 #include <base/strings/string_number_conversions.h>
 #include <base/strings/string_split.h>
@@ -187,13 +188,13 @@
               base::StringToSizeT(verity_table[4], &hash_block_size));
           TEST_AND_RETURN_FALSE(block_size == hash_block_size);
           uint64_t num_data_blocks = 0;
-          TEST_AND_RETURN_FALSE(
-              base::StringToUint64(verity_table[5], &num_data_blocks));
+          TEST_AND_RETURN_FALSE(android::base::ParseUint<uint64_t>(
+              verity_table[5], &num_data_blocks));
           part.verity.hash_tree_data_extent =
               ExtentForRange(0, num_data_blocks);
           uint64_t hash_start_block = 0;
-          TEST_AND_RETURN_FALSE(
-              base::StringToUint64(verity_table[6], &hash_start_block));
+          TEST_AND_RETURN_FALSE(android::base::ParseUint<uint64_t>(
+              verity_table[6], &hash_start_block));
           part.verity.hash_tree_algorithm = verity_table[7];
           TEST_AND_RETURN_FALSE(base::HexStringToBytes(
               verity_table[9], &part.verity.hash_tree_salt));
diff --git a/payload_generator/payload_properties_unittest.cc b/payload_generator/payload_properties_unittest.cc
index b4bfb81..1545d4c 100644
--- a/payload_generator/payload_properties_unittest.cc
+++ b/payload_generator/payload_properties_unittest.cc
@@ -24,7 +24,7 @@
 #include <base/files/scoped_file.h>
 #include <base/files/scoped_temp_dir.h>
 #include <base/rand_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <brillo/data_encoding.h>
 
 #include <gtest/gtest.h>
diff --git a/payload_generator/squashfs_filesystem_unittest.cc b/payload_generator/squashfs_filesystem_unittest.cc
index 68ca9df..b16375b 100644
--- a/payload_generator/squashfs_filesystem_unittest.cc
+++ b/payload_generator/squashfs_filesystem_unittest.cc
@@ -28,7 +28,7 @@
 #include <base/logging.h>
 #include <base/strings/string_number_conversions.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 #include <gtest/gtest.h>
 
 #include "update_engine/common/test_utils.h"
diff --git a/test_http_server.cc b/test_http_server.cc
index ba5e9ac..24f6261 100644
--- a/test_http_server.cc
+++ b/test_http_server.cc
@@ -23,7 +23,6 @@
 // GET a url.
 
 #include <err.h>
-#include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
 #include <netinet/in.h>
@@ -36,7 +35,6 @@
 #include <sys/types.h>
 #include <unistd.h>
 
-#include <algorithm>
 #include <string>
 #include <vector>
 
@@ -44,7 +42,7 @@
 #include <base/posix/eintr_wrapper.h>
 #include <base/strings/string_split.h>
 #include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
+#include <android-base/stringprintf.h>
 
 #include "update_engine/common/http_common.h"
 
@@ -130,15 +128,15 @@
       if (range.find('-') < range.length() - 1)
         request->end_offset = atoll(range.c_str() + range.find('-') + 1) + 1;
       request->return_code = kHttpResponsePartialContent;
-      string tmp_str = base::StringPrintf(
+      string tmp_str = android::base::StringPrintf(
           "decoded range offsets: "
           "start=%jd end=",
           (intmax_t)request->start_offset);
       if (request->end_offset > 0)
-        base::StringAppendF(
+        android::base::StringAppendF(
             &tmp_str, "%jd (non-inclusive)", (intmax_t)request->end_offset);
       else
-        base::StringAppendF(&tmp_str, "unspecified");
+        android::base::StringAppendF(&tmp_str, "unspecified");
       LOG(INFO) << tmp_str;
     } else if (terms[0] == "Host:") {
       CHECK_EQ(terms.size(), static_cast<vector<string>::size_type>(2));
@@ -642,7 +640,8 @@
   // unit tests, avoid unilateral changes; (b) it is necessary to flush/sync the
   // file to prevent the spawning process from waiting indefinitely for this
   // message.
-  string listening_msg = base::StringPrintf("%s%hu", kListeningMsgPrefix, port);
+  string listening_msg =
+      android::base::StringPrintf("%s%hu", kListeningMsgPrefix, port);
   LOG(INFO) << listening_msg;
   CHECK_EQ(write(report_fd, listening_msg.c_str(), listening_msg.length()),
            static_cast<int>(listening_msg.length()));