Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 58021d15 authored by Colin Cross's avatar Colin Cross
Browse files

Move adb_dirname and adb_basename to libbase 

adb already provides an implementation of dirname and basename that
take and produce std::strings, move it into libbase so it can be
used in the implementation of GetExecutableDirectory.

Test: out/host/linux-x86/nativetest64/adb_test/adb_test
Test: out/host/linux-x86/nativetest64/libbase_test/libbase_test
Test: adb shell /data/nativetest64/libbase_test/libbase_test64
Change-Id: Ideb1627607b14562121316d4ed27fa6fb0930684
parent 0cde0eae

adb/adb_utils.cpp

+2 −49
Original line number Diff line number Diff line
@@ -19,16 +19,15 @@ 
#include "adb_utils.h"

#include "adb_unique_fd.h"



#include <libgen.h>

#include <stdlib.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <unistd.h>



#include <algorithm>

#include <mutex>

#include <vector>



#include <android-base/file.h>

#include <android-base/logging.h>

#include <android-base/parseint.h>

#include <android-base/stringprintf.h>
@@ -100,52 +99,6 @@ std::string escape_arg(const std::string& s) { 
  return result;

}



std::string adb_basename(const std::string& path) {

  static std::mutex& basename_lock = *new std::mutex();



  // Copy path because basename may modify the string passed in.

  std::string result(path);



  // Use lock because basename() may write to a process global and return a

  // pointer to that. Note that this locking strategy only works if all other

  // callers to basename in the process also grab this same lock.

  std::lock_guard<std::mutex> lock(basename_lock);



  // Note that if std::string uses copy-on-write strings, &str[0] will cause

  // the copy to be made, so there is no chance of us accidentally writing to

  // the storage for 'path'.

  char* name = basename(&result[0]);



  // In case dirname returned a pointer to a process global, copy that string

  // before leaving the lock.

  result.assign(name);



  return result;

}



std::string adb_dirname(const std::string& path) {

  static std::mutex& dirname_lock = *new std::mutex();



  // Copy path because dirname may modify the string passed in.

  std::string result(path);



  // Use lock because dirname() may write to a process global and return a

  // pointer to that. Note that this locking strategy only works if all other

  // callers to dirname in the process also grab this same lock.

  std::lock_guard<std::mutex> lock(dirname_lock);



  // Note that if std::string uses copy-on-write strings, &str[0] will cause

  // the copy to be made, so there is no chance of us accidentally writing to

  // the storage for 'path'.

  char* parent = dirname(&result[0]);



  // In case dirname returned a pointer to a process global, copy that string

  // before leaving the lock.

  result.assign(parent);



  return result;

}



// Given a relative or absolute filepath, create the directory hierarchy

// as needed. Returns true if the hierarchy is/was setup.

bool mkdirs(const std::string& path) {
@@ -171,7 +124,7 @@ bool mkdirs(const std::string& path) { 
    return true;

  }



  const std::string parent(adb_dirname(path));

  const std::string parent(android::base::Dirname(path));



  // If dirname returned the same path as what we passed in, don't go recursive.

  // This can happen on Windows when walking up the directory hierarchy and not

adb/adb_utils.h

+0 −5
Original line number Diff line number Diff line
@@ -28,11 +28,6 @@ void close_stdin(); 
bool getcwd(std::string* cwd);

bool directory_exists(const std::string& path);



// Like the regular basename and dirname, but thread-safe on all

// platforms and capable of correctly handling exotic Windows paths.

std::string adb_basename(const std::string& path);

std::string adb_dirname(const std::string& path);



// Return the user's home directory.

std::string adb_get_homedir_path();

adb/adb_utils_test.cpp

+0 −12
Original line number Diff line number Diff line
@@ -109,18 +109,6 @@ TEST(adb_utils, escape_arg) { 
  ASSERT_EQ(R"('abc)')", escape_arg("abc)"));

}



TEST(adb_utils, adb_basename) {

  EXPECT_EQ("sh", adb_basename("/system/bin/sh"));

  EXPECT_EQ("sh", adb_basename("sh"));

  EXPECT_EQ("sh", adb_basename("/system/bin/sh/"));

}



TEST(adb_utils, adb_dirname) {

  EXPECT_EQ("/system/bin", adb_dirname("/system/bin/sh"));

  EXPECT_EQ(".", adb_dirname("sh"));

  EXPECT_EQ("/system/bin", adb_dirname("/system/bin/sh/"));

}



void test_mkdirs(const std::string& basepath) {

  // Test creating a directory hierarchy.

  ASSERT_TRUE(mkdirs(basepath));

adb/bugreport.cpp

+3 −2
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 
#include <string>

#include <vector>



#include <android-base/file.h>

#include <android-base/strings.h>



#include "sysdeps.h"
@@ -113,14 +114,14 @@ class BugreportStandardStreamsCallback : public StandardStreamsCallbackInterface 


  private:

    void SetLineMessage(const std::string& action) {

        line_message_ = action + " " + adb_basename(dest_file_);

        line_message_ = action + " " + android::base::Basename(dest_file_);

    }



    void SetSrcFile(const std::string path) {

        src_file_ = path;

        if (!dest_dir_.empty()) {

            // Only uses device-provided name when user passed a directory.

            dest_file_ = adb_basename(path);

            dest_file_ = android::base::Basename(path);

            SetLineMessage("generating");

        }

    }

adb/commandline.cpp

+3 −2
Original line number Diff line number Diff line
@@ -2115,7 +2115,8 @@ static int install_multiple_app(TransportType transport, const char* serial, int 


        std::string cmd = android::base::StringPrintf(

                "%s install-write -S %" PRIu64 " %d %d_%s -",

                install_cmd.c_str(), static_cast<uint64_t>(sb.st_size), session_id, i, adb_basename(file).c_str());

                install_cmd.c_str(), static_cast<uint64_t>(sb.st_size), session_id, i,

                android::base::Basename(file).c_str());



        int localFd = adb_open(file, O_RDONLY);

        if (localFd < 0) {
@@ -2233,7 +2234,7 @@ static int install_app_legacy(TransportType transport, const char* serial, int a 
    int result = -1;

    std::vector<const char*> apk_file = {argv[last_apk]};

    std::string apk_dest = android::base::StringPrintf(

        where, adb_basename(argv[last_apk]).c_str());

        where, android::base::Basename(argv[last_apk]).c_str());

    if (!do_sync_push(apk_file, apk_dest.c_str())) goto cleanup_apk;

    argv[last_apk] = apk_dest.c_str(); /* destination name, not source location */

    result = pm_command(transport, serial, argc, argv);