Use absl::StripAsciiWhitespace instead of android::base::Trim

base/cvd/cuttlefish/common/libs/utils/proc_file_utils.cpp

@@ -26,7 +26,7 @@
 #include <vector>
 
 #include <android-base/file.h>
-#include <android-base/strings.h>
+#include "absl/strings/ascii.h"
 #include "absl/strings/strip.h"
 #include "absl/strings/str_split.h"
 #include <fmt/core.h>
@@ -172,7 +172,7 @@ static Result<void> CheckExecNameFromStatus(const std::string& exec_name,
     if (!absl::ConsumePrefix(&line, "Name:")) {
       continue;
     }
-    if (android::base::Trim(line) == exec_name) {
+    if (absl::StripAsciiWhitespace(line) == exec_name) {
       found = true;
       break;
     }

base/cvd/cuttlefish/host/commands/assemble_cvd/vendor_dlkm_utils.cc

@@ -26,10 +26,10 @@
 #include <vector>
 
 #include "absl/log/log.h"
+#include "absl/strings/ascii.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_split.h"
 #include "android-base/file.h"
-#include "android-base/strings.h"
 #include "fmt/format.h"
 
 #include "cuttlefish/common/libs/fs/shared_buf.h"
@@ -235,7 +235,7 @@ bool WriteDepsToFile(
 std::map<std::string, std::vector<std::string>> LoadModuleDeps(
     const std::string& filename) {
   std::map<std::string, std::vector<std::string>> dependency_map;
-  const auto dep_str = android::base::Trim(ReadFile(filename));
+  const std::string dep_str(absl::StripAsciiWhitespace(ReadFile(filename)));
   const std::vector<std::string_view> dep_lines = absl::StrSplit(dep_str, "\n");
   for (const auto& line : dep_lines) {
     const auto mod_name = line.substr(0, line.find(":"));
@@ -435,7 +435,7 @@ Result<void> SplitRamdiskModules(const std::string& ramdisk_path,
   std::string module_load_file =
       CF_EXPECT(FindFile(ramdisk_stage_dir, "modules.load"),
                 "Failed to find modules.dep file in input ramdisk");
-  module_load_file = android::base::Trim(module_load_file);
+  module_load_file = std::string(absl::StripAsciiWhitespace(module_load_file));
 
   CF_EXPECTF(!module_load_file.empty(),
              "Failed to find modules.dep file in input ramdisk '{}'",

base/cvd/cuttlefish/host/commands/cvd/cli/selector/selector.cpp

@@ -24,7 +24,7 @@
 #include <utility>
 #include <vector>
 
-#include <android-base/strings.h>
+#include "absl/strings/ascii.h"
 #include "absl/strings/numbers.h"
 
 #include "cuttlefish/host/commands/cvd/cli/interruptible_terminal.h"
@@ -114,7 +114,7 @@ Result<LocalInstanceGroup> PromptUserForGroup(
       }
       chosen_group_name = groups[selection].GroupName();
     } else {
-      chosen_group_name = android::base::Trim(input_line);
+      chosen_group_name = std::string(absl::StripAsciiWhitespace(input_line));
     }
 
     filter.group_name = chosen_group_name;

base/cvd/cuttlefish/host/commands/kernel_log_monitor/kernel_log_server.cc

@@ -25,7 +25,7 @@
 #include <utility>
 #include <vector>
 
-#include <android-base/strings.h>
+#include "absl/strings/ascii.h"
 #include "absl/strings/str_split.h"
 #include "absl/log/log.h"
 
@@ -161,8 +161,8 @@ bool KernelLogServer::HandleIncomingMessage() {
             // Expect space-separated key=value pairs in the log message.
             const std::vector<std::string> fields =
                 absl::StrSplit(line_.substr(pos + stage.size()), ' ');
-            for (std::string field : fields) {
-              field = android::base::Trim(field);
+            for (std::string_view field : fields) {
+              field = absl::StripAsciiWhitespace(field);
               if (field.empty()) {
                 // Expected; absl::StrSplit() always returns at least
                 // one (possibly empty) string.

base/cvd/cuttlefish/host/commands/log_tee/log_tee.cpp

@@ -20,7 +20,7 @@
 
 #include <regex>
 
-#include <android-base/strings.h>
+#include "absl/strings/ascii.h"
 #include <gflags/gflags.h>
 #include "absl/log/check.h"
 #include "absl/log/log.h"
@@ -136,7 +136,8 @@ int main(int argc, char** argv) {
       if (chars_read == 0) {
         break;
       }
-      auto trimmed = android::base::Trim(std::string_view(buf, chars_read));
+      std::string trimmed(
+          absl::StripAsciiWhitespace(std::string_view(buf, chars_read)));
       // Newlines inside `trimmed` are handled by the android logging code.
       // These checks attempt to determine the log severity coming from crosvm.
       // There is no guarantee of success all the time since log line boundaries

base/cvd/cuttlefish/host/libs/control_env/grpc_service_handler.cc

@@ -24,9 +24,9 @@
 #include <vector>
 
 #include "absl/log/log.h"
+#include "absl/strings/ascii.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_split.h"
-#include "android-base/strings.h"
 #include "grpcpp/security/credentials.h"
 #include "json/json.h"
 #include "test/cpp/util/cli_credentials.h"
@@ -38,7 +38,6 @@
 
 using absl::EndsWith;
 using absl::StrSplit;
-using android::base::Trim;
 using grpc::InsecureChannelCredentials;
 
 namespace cuttlefish {
@@ -198,7 +197,7 @@ Result<std::string> HandleLsCmd(
       Json::Value json;
       json["services"] = Json::Value(Json::arrayValue);
       for (std::string_view full_service_name :
-           StrSplit(Trim(command_output), "\n")) {
+           StrSplit(absl::StripAsciiWhitespace(command_output), "\n")) {
         if (full_service_name == kServiceServerReflection ||
             full_service_name == kServiceHealth ||
             full_service_name == kServiceControlEnvProxyFull) {
@@ -225,8 +224,8 @@ Result<std::string> HandleLsCmd(
 
       Json::Value json;
       json["methods"] = Json::Value(Json::arrayValue);
-      for (const auto& method_name :
-           std::vector<std::string>(StrSplit(Trim(command_output), "\n"))) {
+      for (const auto& method_name : std::vector<std::string>(
+               StrSplit(absl::StripAsciiWhitespace(command_output), "\n"))) {
         json["methods"].append(method_name);
       }
       Json::StreamWriterBuilder builder;
@@ -252,7 +251,7 @@ Result<std::string> HandleLsCmd(
       //   rpc SetTxpower(wmediumdserver.SetTxpowerRequest) returns
       // (google.protobuf.Empty) {}
       std::vector<std::string> parsed_output =
-          StrSplit(Trim(command_output), "()");
+          StrSplit(absl::StripAsciiWhitespace(command_output), "()");
       CF_EXPECT(parsed_output.size() == 5, "Unexpected parsing result");
       Json::Value json;
       json["request_type"] = parsed_output[1];

base/cvd/cuttlefish/host/libs/screen_connector/composition_manager.cpp

@@ -34,7 +34,7 @@
 #include <string_view>
 #include <vector>
 
-#include <android-base/strings.h>
+#include "absl/strings/ascii.h"
 #include "absl/strings/str_split.h"
 #include "absl/log/log.h"
 #include "absl/strings/numbers.h"
@@ -77,7 +77,8 @@ CompositionManager::ParseOverlays(std::vector<std::string> overlay_items) {
   // index within that vm.  Structured types are created as result.
   for (int display_index = 0; display_index < overlay_items.size();
        display_index++) {
-    auto overlay_item = android::base::Trim(overlay_items[display_index]);
+    std::string_view overlay_item =
+        absl::StripAsciiWhitespace(overlay_items[display_index]);
 
     if (overlay_item.empty() || overlay_item == "_") {
       continue;

base/cvd/cuttlefish/host/libs/web/credential_source.cc

@@ -28,7 +28,7 @@
 #include <utility>
 #include <vector>
 
-#include <android-base/strings.h>
+#include "absl/strings/ascii.h"
 #include "absl/strings/str_replace.h"
 #include "absl/strings/strip.h"
 #include "absl/strings/str_split.h"
@@ -210,18 +210,18 @@ RefreshTokenCredentialSource::FromOauth2ClientFile(
          absl::StrSplit(oauth_contents, '\n', absl::SkipEmpty())) {
       static constexpr std::string_view kClientIdPrefix = "client_id =";
       if (absl::ConsumePrefix(&line, kClientIdPrefix)) {
-        client_id = android::base::Trim(line);
+        client_id = std::string(absl::StripAsciiWhitespace(line));
         continue;
       }
       static constexpr std::string_view kClientSecretPrefix = "client_secret =";
       if (absl::ConsumePrefix(&line, kClientSecretPrefix)) {
-        client_secret = android::base::Trim(line);
+        client_secret = std::string(absl::StripAsciiWhitespace(line));
         continue;
       }
       static constexpr std::string_view kRefreshTokenPrefix =
           "gs_oauth2_refresh_token =";
       if (absl::ConsumePrefix(&line, kRefreshTokenPrefix)) {
-        refresh_token = android::base::Trim(line);
+        refresh_token = std::string(absl::StripAsciiWhitespace(line));
         continue;
       }
     }

base/cvd/cuttlefish/host/libs/web/http_client/BUILD.bazel

@@ -21,6 +21,7 @@ cf_cc_library(
         "//cuttlefish/result",
         "//libbase",
         "@abseil-cpp//absl/log",
+        "@abseil-cpp//absl/strings",
         "@curl",
     ],
 )

base/cvd/cuttlefish/host/libs/web/http_client/curl_http_client.cc

@@ -25,10 +25,11 @@
 #include <memory>
 #include <mutex>
 #include <string>
+#include <string_view>
 #include <utility>
 #include <vector>
 
-#include <android-base/strings.h>
+#include "absl/strings/ascii.h"
 #include "absl/log/log.h"
 
 #include "cuttlefish/host/libs/web/http_client/http_client.h"
@@ -39,8 +40,8 @@ namespace cuttlefish {
 namespace {
 
 std::string TrimWhitespace(const char* data, const size_t size) {
-  std::string converted(data, size);
-  return android::base::Trim(converted);
+  std::string_view converted(data, size);
+  return std::string(absl::StripAsciiWhitespace(converted));
 }
 
 int LoggingCurlDebugFunction(CURL*, curl_infotype type, char* data, size_t size,