namespace vsoc -> namespace cuttlefish
This is a mechanical change using the following commands:
sed -i "s/namespace vsoc/namespace cuttlefish/g" $(find . -type f)
sed -i "s/vsoc::/cuttlefish::/g" $(find . -type f)
sed -i "s/vsoc_input_service::/cuttlefish_input_service::/g" $(find . -type f)
Bug: 159054521
Test: make -j
Change-Id: Iec8cb3c05c3a3376b4f60ae49ff8bcca393db3c1
Merged-In: Iec8cb3c05c3a3376b4f60ae49ff8bcca393db3c1
diff --git a/common/libs/device_config/device_config.h b/common/libs/device_config/device_config.h
index bbd74d1..6db45e6 100644
--- a/common/libs/device_config/device_config.h
+++ b/common/libs/device_config/device_config.h
@@ -76,8 +76,8 @@
void generate_address_and_prefix();
#ifdef CUTTLEFISH_HOST
DeviceConfig() = default;
- bool InitializeNetworkConfiguration(const vsoc::CuttlefishConfig& config);
- void InitializeScreenConfiguration(const vsoc::CuttlefishConfig& config);
+ bool InitializeNetworkConfiguration(const cuttlefish::CuttlefishConfig& config);
+ void InitializeScreenConfiguration(const cuttlefish::CuttlefishConfig& config);
#else
explicit DeviceConfig(const RawData& data);
#endif
diff --git a/common/libs/device_config/host_device_config.cpp b/common/libs/device_config/host_device_config.cpp
index 0a3f0a0..9a9b3ba 100644
--- a/common/libs/device_config/host_device_config.cpp
+++ b/common/libs/device_config/host_device_config.cpp
@@ -139,7 +139,7 @@
} // namespace
std::unique_ptr<DeviceConfig> DeviceConfig::Get() {
- auto config = vsoc::CuttlefishConfig::Get();
+ auto config = cuttlefish::CuttlefishConfig::Get();
if (!config) return nullptr;
std::unique_ptr<DeviceConfig> dev_config(new DeviceConfig());
if (!dev_config->InitializeNetworkConfiguration(*config)) {
@@ -150,7 +150,7 @@
}
bool DeviceConfig::InitializeNetworkConfiguration(
- const vsoc::CuttlefishConfig& config) {
+ const cuttlefish::CuttlefishConfig& config) {
auto instance = config.ForDefaultInstance();
NetConfig netconfig;
// Check the mobile bridge first; this was the traditional way we configured
@@ -184,7 +184,7 @@
}
void DeviceConfig::InitializeScreenConfiguration(
- const vsoc::CuttlefishConfig& config) {
+ const cuttlefish::CuttlefishConfig& config) {
data_.screen.x_res = config.x_res();
data_.screen.y_res = config.y_res();
data_.screen.dpi = config.dpi();
diff --git a/guest/commands/vsoc_input_service/main.cpp b/guest/commands/vsoc_input_service/main.cpp
index c9e93ed..65d6c6c 100644
--- a/guest/commands/vsoc_input_service/main.cpp
+++ b/guest/commands/vsoc_input_service/main.cpp
@@ -21,7 +21,7 @@
int main(int argc, char* argv[]) {
gflags::ParseCommandLineFlags(&argc, &argv, true);
- vsoc_input_service::VSoCInputService service;
+ cuttlefish_input_service::VSoCInputService service;
if (!service.SetUpDevices()) {
return -1;
}
diff --git a/guest/commands/vsoc_input_service/virtual_device_base.cpp b/guest/commands/vsoc_input_service/virtual_device_base.cpp
index 6bfd6c6..b96ee39 100644
--- a/guest/commands/vsoc_input_service/virtual_device_base.cpp
+++ b/guest/commands/vsoc_input_service/virtual_device_base.cpp
@@ -25,7 +25,7 @@
#include "log/log.h"
-using vsoc_input_service::VirtualDeviceBase;
+using cuttlefish_input_service::VirtualDeviceBase;
namespace {
diff --git a/guest/commands/vsoc_input_service/virtual_device_base.h b/guest/commands/vsoc_input_service/virtual_device_base.h
index d25e0e4..2932753 100644
--- a/guest/commands/vsoc_input_service/virtual_device_base.h
+++ b/guest/commands/vsoc_input_service/virtual_device_base.h
@@ -22,7 +22,7 @@
#include <functional>
#include <vector>
-namespace vsoc_input_service {
+namespace cuttlefish_input_service {
class VirtualDeviceBase {
public:
@@ -48,4 +48,4 @@
int fd_ = -1;
};
-} // namespace vsoc_input_service
+} // namespace cuttlefish_input_service
diff --git a/guest/commands/vsoc_input_service/virtual_keyboard.cpp b/guest/commands/vsoc_input_service/virtual_keyboard.cpp
index 80cf0e0..7ffcea5 100644
--- a/guest/commands/vsoc_input_service/virtual_keyboard.cpp
+++ b/guest/commands/vsoc_input_service/virtual_keyboard.cpp
@@ -16,7 +16,7 @@
#include "virtual_keyboard.h"
-namespace vsoc_input_service {
+namespace cuttlefish_input_service {
VirtualKeyboard::VirtualKeyboard()
: VirtualDeviceBase("VSoC keyboard", 0x6008) {}
@@ -63,4 +63,4 @@
return keys;
}
-} // namespace vsoc_input_service
+} // namespace cuttlefish_input_service
diff --git a/guest/commands/vsoc_input_service/virtual_keyboard.h b/guest/commands/vsoc_input_service/virtual_keyboard.h
index b343699..0dd1f42 100644
--- a/guest/commands/vsoc_input_service/virtual_keyboard.h
+++ b/guest/commands/vsoc_input_service/virtual_keyboard.h
@@ -17,7 +17,7 @@
#include "virtual_device_base.h"
-namespace vsoc_input_service {
+namespace cuttlefish_input_service {
class VirtualKeyboard : public VirtualDeviceBase {
public:
@@ -28,4 +28,4 @@
const std::vector<const uint32_t>& GetKeys() const override;
};
-} // namespace vsoc_input_service
+} // namespace cuttlefish_input_service
diff --git a/guest/commands/vsoc_input_service/virtual_power_button.cpp b/guest/commands/vsoc_input_service/virtual_power_button.cpp
index d1758e0..595630b 100644
--- a/guest/commands/vsoc_input_service/virtual_power_button.cpp
+++ b/guest/commands/vsoc_input_service/virtual_power_button.cpp
@@ -16,7 +16,7 @@
#include "virtual_power_button.h"
-namespace vsoc_input_service {
+namespace cuttlefish_input_service {
VirtualPowerButton::VirtualPowerButton()
: VirtualDeviceBase("VSoC power button", 0x6007) {}
@@ -30,4 +30,4 @@
return keys;
}
-} // namespace vsoc_input_service
+} // namespace cuttlefish_input_service
diff --git a/guest/commands/vsoc_input_service/virtual_power_button.h b/guest/commands/vsoc_input_service/virtual_power_button.h
index 220bfdc..95811db 100644
--- a/guest/commands/vsoc_input_service/virtual_power_button.h
+++ b/guest/commands/vsoc_input_service/virtual_power_button.h
@@ -17,7 +17,7 @@
#include "virtual_device_base.h"
-namespace vsoc_input_service {
+namespace cuttlefish_input_service {
class VirtualPowerButton : public VirtualDeviceBase {
public:
@@ -28,4 +28,4 @@
const std::vector<const uint32_t>& GetKeys() const override;
};
-} // namespace vsoc_input_service
+} // namespace cuttlefish_input_service
diff --git a/guest/commands/vsoc_input_service/virtual_touchscreen.cpp b/guest/commands/vsoc_input_service/virtual_touchscreen.cpp
index 72a0d3f..c678573 100644
--- a/guest/commands/vsoc_input_service/virtual_touchscreen.cpp
+++ b/guest/commands/vsoc_input_service/virtual_touchscreen.cpp
@@ -16,7 +16,7 @@
#include "virtual_touchscreen.h"
-namespace vsoc_input_service {
+namespace cuttlefish_input_service {
const std::vector<const uint32_t>& VirtualTouchScreen::GetEventTypes() const {
static const std::vector<const uint32_t> evt_types{EV_ABS, EV_KEY};
@@ -43,4 +43,4 @@
dev_.absmax[ABS_Y] = height;
}
-} // namespace vsoc_input_service
+} // namespace cuttlefish_input_service
diff --git a/guest/commands/vsoc_input_service/virtual_touchscreen.h b/guest/commands/vsoc_input_service/virtual_touchscreen.h
index 9ac806e..a32bcb5 100644
--- a/guest/commands/vsoc_input_service/virtual_touchscreen.h
+++ b/guest/commands/vsoc_input_service/virtual_touchscreen.h
@@ -17,7 +17,7 @@
#include "virtual_device_base.h"
-namespace vsoc_input_service {
+namespace cuttlefish_input_service {
class VirtualTouchScreen : public VirtualDeviceBase {
public:
@@ -30,4 +30,4 @@
virtual const std::vector<const uint32_t>& GetAbs() const;
};
-} // namespace vsoc_input_service
+} // namespace cuttlefish_input_service
diff --git a/guest/commands/vsoc_input_service/vsoc_input_service.cpp b/guest/commands/vsoc_input_service/vsoc_input_service.cpp
index 0cb56ef..acda3c1 100644
--- a/guest/commands/vsoc_input_service/vsoc_input_service.cpp
+++ b/guest/commands/vsoc_input_service/vsoc_input_service.cpp
@@ -29,12 +29,12 @@
#include "common/libs/fs/shared_fd.h"
#include "common/libs/device_config/device_config.h"
-using vsoc::input_events::InputEvent;
-using vsoc_input_service::VirtualDeviceBase;
-using vsoc_input_service::VirtualKeyboard;
-using vsoc_input_service::VirtualPowerButton;
-using vsoc_input_service::VirtualTouchScreen;
-using vsoc_input_service::VSoCInputService;
+using cuttlefish::input_events::InputEvent;
+using cuttlefish_input_service::VirtualDeviceBase;
+using cuttlefish_input_service::VirtualKeyboard;
+using cuttlefish_input_service::VirtualPowerButton;
+using cuttlefish_input_service::VirtualTouchScreen;
+using cuttlefish_input_service::VSoCInputService;
DEFINE_uint32(keyboard_port, 0, "keyboard vsock port");
DEFINE_uint32(touch_port, 0, "keyboard vsock port");
diff --git a/guest/commands/vsoc_input_service/vsoc_input_service.h b/guest/commands/vsoc_input_service/vsoc_input_service.h
index edf196d..d8aea81 100644
--- a/guest/commands/vsoc_input_service/vsoc_input_service.h
+++ b/guest/commands/vsoc_input_service/vsoc_input_service.h
@@ -21,7 +21,7 @@
#include "virtual_power_button.h"
#include "virtual_touchscreen.h"
-namespace vsoc {
+namespace cuttlefish {
namespace input_events {
struct InputEvent {
@@ -31,9 +31,9 @@
};
} // namespace input_events
-} // namespace vsoc
+} // namespace cuttlefish
-namespace vsoc_input_service {
+namespace cuttlefish_input_service {
class VSoCInputService {
public:
@@ -46,4 +46,4 @@
std::shared_ptr<VirtualTouchScreen> virtual_touchscreen_;
};
-} // namespace vsoc_input_service
+} // namespace cuttlefish_input_service
diff --git a/guest/hals/gralloc/legacy/gralloc.cpp b/guest/hals/gralloc/legacy/gralloc.cpp
index 28e71eb..2da3ac9 100644
--- a/guest/hals/gralloc/legacy/gralloc.cpp
+++ b/guest/hals/gralloc/legacy/gralloc.cpp
@@ -38,7 +38,7 @@
#include "gralloc_vsoc_priv.h"
#include "region_registry.h"
-using vsoc::screen::ScreenRegionView;
+using cuttlefish::screen::ScreenRegionView;
/*****************************************************************************/
diff --git a/guest/hals/gralloc/legacy/gralloc_vsoc_priv.h b/guest/hals/gralloc/legacy/gralloc_vsoc_priv.h
index 390c654..987a092 100644
--- a/guest/hals/gralloc/legacy/gralloc_vsoc_priv.h
+++ b/guest/hals/gralloc/legacy/gralloc_vsoc_priv.h
@@ -43,7 +43,7 @@
};
#endif
-namespace vsoc {
+namespace cuttlefish {
namespace screen {
struct ScreenRegionView {
@@ -258,9 +258,9 @@
#ifdef GRALLOC_MODULE_API_VERSION_0_2
case HAL_PIXEL_FORMAT_YCbCr_420_888:
#endif
- out->ystride = vsoc::screen::ScreenRegionView::align(width);
+ out->ystride = cuttlefish::screen::ScreenRegionView::align(width);
out->cstride =
- vsoc::screen::ScreenRegionView::align(out->ystride / 2);
+ cuttlefish::screen::ScreenRegionView::align(out->ystride / 2);
out->chroma_step = 1;
out->y = it;
it += out->ystride * height;
@@ -295,17 +295,17 @@
y_size = strides.ystride * h;
c_size = strides.cstride * h / 2;
return (y_size + 2 * c_size +
- vsoc::screen::ScreenRegionView::kSwiftShaderPadding);
+ cuttlefish::screen::ScreenRegionView::kSwiftShaderPadding);
/*case HAL_PIXEL_FORMAT_RGBA_8888:
case HAL_PIXEL_FORMAT_RGBX_8888:
case HAL_PIXEL_FORMAT_BGRA_8888:
case HAL_PIXEL_FORMAT_RGB_888:
case HAL_PIXEL_FORMAT_RGB_565:*/
default:
- w16 = vsoc::screen::ScreenRegionView::align(w);
- h16 = vsoc::screen::ScreenRegionView::align(h);
+ w16 = cuttlefish::screen::ScreenRegionView::align(w);
+ h16 = cuttlefish::screen::ScreenRegionView::align(h);
return bytes_per_pixel * w16 * h16 +
- vsoc::screen::ScreenRegionView::kSwiftShaderPadding;
+ cuttlefish::screen::ScreenRegionView::kSwiftShaderPadding;
}
}
diff --git a/host/commands/adbshell/main.cpp b/host/commands/adbshell/main.cpp
index 95f5fef..f971ab5 100644
--- a/host/commands/adbshell/main.cpp
+++ b/host/commands/adbshell/main.cpp
@@ -57,7 +57,7 @@
std::string cvd_prefix = "cvd-";
if (user.find(cvd_prefix) == 0) {
- user.replace(0, cvd_prefix.size(), vsoc::kVsocUserPrefix);
+ user.replace(0, cvd_prefix.size(), cuttlefish::kVsocUserPrefix);
}
return user;
}
@@ -76,14 +76,14 @@
}
void SetCuttlefishConfigEnv() {
- setenv(vsoc::kCuttlefishConfigEnvVarName, CuttlefishConfigLocation().c_str(),
+ setenv(cuttlefish::kCuttlefishConfigEnvVarName, CuttlefishConfigLocation().c_str(),
true);
}
} // namespace
int main(int argc, char* argv[]) {
SetCuttlefishConfigEnv();
- auto instance = vsoc::CuttlefishConfig::Get()
+ auto instance = cuttlefish::CuttlefishConfig::Get()
->ForDefaultInstance().adb_device_name();
std::string adb_path = CuttlefishFindAdb();
diff --git a/host/commands/assemble_cvd/boot_config.cc b/host/commands/assemble_cvd/boot_config.cc
index bdfdf09..7e1171c 100644
--- a/host/commands/assemble_cvd/boot_config.cc
+++ b/host/commands/assemble_cvd/boot_config.cc
@@ -32,7 +32,7 @@
namespace {
-size_t WriteEnvironment(const vsoc::CuttlefishConfig& config,
+size_t WriteEnvironment(const cuttlefish::CuttlefishConfig& config,
const std::string& env_path) {
std::ostringstream env;
auto kernel_args = KernelCommandLineFromConfig(config);
@@ -58,7 +58,7 @@
} // namespace
-bool InitBootloaderEnvPartition(const vsoc::CuttlefishConfig& config,
+bool InitBootloaderEnvPartition(const cuttlefish::CuttlefishConfig& config,
const std::string& boot_env_image_path) {
auto tmp_boot_env_image_path = boot_env_image_path + ".tmp";
auto uboot_env_path = config.AssemblyPath("u-boot.env");
@@ -67,7 +67,7 @@
return false;
}
- auto mkimage_path = vsoc::DefaultHostArtifactsPath("bin/mkenvimage");
+ auto mkimage_path = cuttlefish::DefaultHostArtifactsPath("bin/mkenvimage");
cuttlefish::Command cmd(mkimage_path);
cmd.AddParameter("-s");
cmd.AddParameter("4096");
diff --git a/host/commands/assemble_cvd/boot_config.h b/host/commands/assemble_cvd/boot_config.h
index a7b6a12..8a3148c 100644
--- a/host/commands/assemble_cvd/boot_config.h
+++ b/host/commands/assemble_cvd/boot_config.h
@@ -18,5 +18,5 @@
#include <string>
#include <host/libs/config/cuttlefish_config.h>
-bool InitBootloaderEnvPartition(const vsoc::CuttlefishConfig& config,
+bool InitBootloaderEnvPartition(const cuttlefish::CuttlefishConfig& config,
const std::string& boot_env_image_path);
diff --git a/host/commands/assemble_cvd/data_image.cc b/host/commands/assemble_cvd/data_image.cc
index 60d05a1..b1f050e 100644
--- a/host/commands/assemble_cvd/data_image.cc
+++ b/host/commands/assemble_cvd/data_image.cc
@@ -19,7 +19,7 @@
const int FSCK_ERROR_CORRECTED_REQUIRES_REBOOT = 2;
bool ForceFsckImage(const char* data_image) {
- auto fsck_path = vsoc::DefaultHostArtifactsPath("bin/fsck.f2fs");
+ auto fsck_path = cuttlefish::DefaultHostArtifactsPath("bin/fsck.f2fs");
int fsck_status = cuttlefish::execute({fsck_path, "-y", "-f", data_image});
if (fsck_status & ~(FSCK_ERROR_CORRECTED|FSCK_ERROR_CORRECTED_REQUIRES_REBOOT)) {
LOG(ERROR) << "`fsck.f2fs -y -f " << data_image << "` failed with code "
@@ -50,7 +50,7 @@
if (!fsck_success) {
return false;
}
- auto resize_path = vsoc::DefaultHostArtifactsPath("bin/resize.f2fs");
+ auto resize_path = cuttlefish::DefaultHostArtifactsPath("bin/resize.f2fs");
int resize_status = cuttlefish::execute({resize_path, data_image});
if (resize_status != 0) {
LOG(ERROR) << "`resize.f2fs " << data_image << "` failed with code "
@@ -85,7 +85,7 @@
if (image_fmt == "ext4") {
cuttlefish::execute({"/sbin/mkfs.ext4", image});
} else if (image_fmt == "f2fs") {
- auto make_f2fs_path = vsoc::DefaultHostArtifactsPath("bin/make_f2fs");
+ auto make_f2fs_path = cuttlefish::DefaultHostArtifactsPath("bin/make_f2fs");
cuttlefish::execute({make_f2fs_path, "-t", image_fmt, image, "-g", "android"});
} else if (image_fmt == "sdcard") {
// Reserve 1MB in the image for the MBR and padding, to simulate what
@@ -93,7 +93,7 @@
off_t offset_size_bytes = 1 << 20;
image_size_bytes -= offset_size_bytes;
off_t image_size_sectors = image_size_bytes / 512;
- auto newfs_msdos_path = vsoc::DefaultHostArtifactsPath("bin/newfs_msdos");
+ auto newfs_msdos_path = cuttlefish::DefaultHostArtifactsPath("bin/newfs_msdos");
cuttlefish::execute({newfs_msdos_path, "-F", "32", "-m", "0xf8", "-a", "4088",
"-o", "0", "-c", "8", "-h", "255",
"-u", "63", "-S", "512",
@@ -122,7 +122,7 @@
}
}
-DataImageResult ApplyDataImagePolicy(const vsoc::CuttlefishConfig& config,
+DataImageResult ApplyDataImagePolicy(const cuttlefish::CuttlefishConfig& config,
const std::string& data_image) {
bool data_exists = cuttlefish::FileHasContent(data_image.c_str());
bool remove{};
diff --git a/host/commands/assemble_cvd/data_image.h b/host/commands/assemble_cvd/data_image.h
index e4afdf8..b7b626b 100644
--- a/host/commands/assemble_cvd/data_image.h
+++ b/host/commands/assemble_cvd/data_image.h
@@ -10,7 +10,7 @@
FileUpdated,
};
-DataImageResult ApplyDataImagePolicy(const vsoc::CuttlefishConfig& config,
+DataImageResult ApplyDataImagePolicy(const cuttlefish::CuttlefishConfig& config,
const std::string& path);
bool InitializeMiscImage(const std::string& misc_image);
void CreateBlankImage(
diff --git a/host/commands/assemble_cvd/flags.cc b/host/commands/assemble_cvd/flags.cc
index a018c2a..9572102 100644
--- a/host/commands/assemble_cvd/flags.cc
+++ b/host/commands/assemble_cvd/flags.cc
@@ -34,7 +34,7 @@
// Taken from external/avb/libavb/avb_slot_verify.c; this define is not in the headers
#define VBMETA_MAX_SIZE 65536ul
-using vsoc::ForCurrentInstance;
+using cuttlefish::ForCurrentInstance;
using cuttlefish::AssemblerExitCodes;
DEFINE_string(cache_image, "", "Location of the cache partition image.");
@@ -91,7 +91,7 @@
DEFINE_string(serial_number, ForCurrentInstance("CUTTLEFISHCVD"),
"Serial number to use for the device");
DEFINE_string(assembly_dir,
- vsoc::DefaultHostArtifactsPath("cuttlefish_assembly"),
+ cuttlefish::DefaultHostArtifactsPath("cuttlefish_assembly"),
"A directory to put generated files common between instances");
DEFINE_string(instance_dir,
cuttlefish::StringFromEnv("HOME", ".") + "/cuttlefish_runtime",
@@ -100,10 +100,10 @@
vm_manager, vm_manager::CrosvmManager::name(),
"What virtual machine manager to use, one of {qemu_cli, crosvm}");
DEFINE_string(
- gpu_mode, vsoc::kGpuModeGuestSwiftshader,
+ gpu_mode, cuttlefish::kGpuModeGuestSwiftshader,
"What gpu configuration to use, one of {guest_swiftshader, drm_virgl}");
-DEFINE_string(system_image_dir, vsoc::DefaultGuestImagePath(""),
+DEFINE_string(system_image_dir, cuttlefish::DefaultGuestImagePath(""),
"Location of the system partition images.");
DEFINE_string(super_image, "", "Location of the super partition image.");
DEFINE_string(misc_image, "",
@@ -144,19 +144,19 @@
static const std::string kSeccompDir =
std::string("usr/share/cuttlefish/") + cuttlefish::HostArch() + "-linux-gnu/seccomp";
DEFINE_string(seccomp_policy_dir,
- vsoc::DefaultHostArtifactsPath(kSeccompDir),
+ cuttlefish::DefaultHostArtifactsPath(kSeccompDir),
"With sandbox'ed crosvm, overrieds the security comp policy directory");
DEFINE_bool(start_webrtc, false, "Whether to start the webrtc process.");
DEFINE_string(
webrtc_assets_dir,
- vsoc::DefaultHostArtifactsPath("usr/share/webrtc/assets"),
+ cuttlefish::DefaultHostArtifactsPath("usr/share/webrtc/assets"),
"[Experimental] Path to WebRTC webpage assets.");
DEFINE_string(
webrtc_certs_dir,
- vsoc::DefaultHostArtifactsPath("usr/share/webrtc/certs"),
+ cuttlefish::DefaultHostArtifactsPath("usr/share/webrtc/certs"),
"[Experimental] Path to WebRTC certificates directory.");
DEFINE_string(
@@ -209,7 +209,7 @@
"Maintain adb connection by sending 'adb connect' commands to the "
"server. Only relevant with -adb_mode=tunnel or vsock_tunnel");
-DEFINE_string(uuid, vsoc::ForCurrentInstance(vsoc::kDefaultUuidPrefix),
+DEFINE_string(uuid, cuttlefish::ForCurrentInstance(cuttlefish::kDefaultUuidPrefix),
"UUID to use for the device. Random if not specified");
DEFINE_bool(daemon, false,
"Run cuttlefish in background, the launcher exits on boot "
@@ -224,7 +224,7 @@
"/usr/bin/qemu-system-x86_64",
"The qemu binary to use");
DEFINE_string(crosvm_binary,
- vsoc::DefaultHostArtifactsPath("bin/crosvm"),
+ cuttlefish::DefaultHostArtifactsPath("bin/crosvm"),
"The Crosvm binary to use");
DEFINE_string(tpm_binary, "",
"The TPM simulator to use. Disabled if empty.");
@@ -319,13 +319,13 @@
// Initializes the config object and saves it to file. It doesn't return it, all
// further uses of the config should happen through the singleton
-vsoc::CuttlefishConfig InitializeCuttlefishConfiguration(
+cuttlefish::CuttlefishConfig InitializeCuttlefishConfiguration(
const cuttlefish::BootImageUnpacker& boot_image_unpacker,
const cuttlefish::FetcherConfig& fetcher_config) {
// At most one streamer can be started.
CHECK(NumStreamers() <= 1);
- vsoc::CuttlefishConfig tmp_config_obj;
+ cuttlefish::CuttlefishConfig tmp_config_obj;
tmp_config_obj.set_assembly_dir(FLAGS_assembly_dir);
if (!vm_manager::VmManager::IsValidName(FLAGS_vm_manager)) {
LOG(FATAL) << "Invalid vm_manager: " << FLAGS_vm_manager;
@@ -403,22 +403,22 @@
tmp_config_obj.set_deprecated_boot_completed(FLAGS_deprecated_boot_completed);
tmp_config_obj.set_logcat_receiver_binary(
- vsoc::DefaultHostArtifactsPath("bin/logcat_receiver"));
+ cuttlefish::DefaultHostArtifactsPath("bin/logcat_receiver"));
tmp_config_obj.set_config_server_binary(
- vsoc::DefaultHostArtifactsPath("bin/config_server"));
+ cuttlefish::DefaultHostArtifactsPath("bin/config_server"));
tmp_config_obj.set_qemu_binary(FLAGS_qemu_binary);
tmp_config_obj.set_crosvm_binary(FLAGS_crosvm_binary);
tmp_config_obj.set_tpm_binary(FLAGS_tpm_binary);
tmp_config_obj.set_tpm_device(FLAGS_tpm_device);
tmp_config_obj.set_console_forwarder_binary(
- vsoc::DefaultHostArtifactsPath("bin/console_forwarder"));
+ cuttlefish::DefaultHostArtifactsPath("bin/console_forwarder"));
tmp_config_obj.set_kernel_log_monitor_binary(
- vsoc::DefaultHostArtifactsPath("bin/kernel_log_monitor"));
+ cuttlefish::DefaultHostArtifactsPath("bin/kernel_log_monitor"));
tmp_config_obj.set_enable_vnc_server(FLAGS_start_vnc_server);
tmp_config_obj.set_vnc_server_binary(
- vsoc::DefaultHostArtifactsPath("bin/vnc_server"));
+ cuttlefish::DefaultHostArtifactsPath("bin/vnc_server"));
tmp_config_obj.set_enable_sandbox(FLAGS_enable_sandbox);
@@ -426,12 +426,12 @@
tmp_config_obj.set_enable_webrtc(FLAGS_start_webrtc);
tmp_config_obj.set_webrtc_binary(
- vsoc::DefaultHostArtifactsPath("bin/webRTC"));
+ cuttlefish::DefaultHostArtifactsPath("bin/webRTC"));
tmp_config_obj.set_webrtc_assets_dir(FLAGS_webrtc_assets_dir);
tmp_config_obj.set_webrtc_public_ip(FLAGS_webrtc_public_ip);
tmp_config_obj.set_webrtc_certs_dir(FLAGS_webrtc_certs_dir);
tmp_config_obj.set_sig_server_binary(
- vsoc::DefaultHostArtifactsPath("bin/webrtc_sig_server"));
+ cuttlefish::DefaultHostArtifactsPath("bin/webrtc_sig_server"));
// Note: This will be overridden if the sig server is started by us
tmp_config_obj.set_sig_server_port(FLAGS_webrtc_sig_server_port);
tmp_config_obj.set_sig_server_address(FLAGS_webrtc_sig_server_addr);
@@ -444,9 +444,9 @@
tmp_config_obj.set_restart_subprocesses(FLAGS_restart_subprocesses);
tmp_config_obj.set_run_adb_connector(FLAGS_run_adb_connector);
tmp_config_obj.set_adb_connector_binary(
- vsoc::DefaultHostArtifactsPath("bin/adb_connector"));
+ cuttlefish::DefaultHostArtifactsPath("bin/adb_connector"));
tmp_config_obj.set_socket_vsock_proxy_binary(
- vsoc::DefaultHostArtifactsPath("bin/socket_vsock_proxy"));
+ cuttlefish::DefaultHostArtifactsPath("bin/socket_vsock_proxy"));
tmp_config_obj.set_run_as_daemon(FLAGS_daemon);
tmp_config_obj.set_data_policy(FLAGS_data_policy);
@@ -457,14 +457,14 @@
tmp_config_obj.set_enable_tombstone_receiver(FLAGS_enable_tombstone_receiver);
tmp_config_obj.set_tombstone_receiver_binary(
- vsoc::DefaultHostArtifactsPath("bin/tombstone_receiver"));
+ cuttlefish::DefaultHostArtifactsPath("bin/tombstone_receiver"));
tmp_config_obj.set_use_bootloader(FLAGS_use_bootloader);
tmp_config_obj.set_bootloader(FLAGS_bootloader);
tmp_config_obj.set_enable_metrics(FLAGS_report_anonymous_usage_stats);
tmp_config_obj.set_metrics_binary(
- vsoc::DefaultHostArtifactsPath("bin/metrics"));
+ cuttlefish::DefaultHostArtifactsPath("bin/metrics"));
if (!FLAGS_boot_slot.empty()) {
tmp_config_obj.set_boot_slot(FLAGS_boot_slot);
@@ -476,13 +476,13 @@
std::vector<int> instance_nums;
for (int i = 0; i < FLAGS_num_instances; i++) {
- instance_nums.push_back(vsoc::GetInstance() + i);
+ instance_nums.push_back(cuttlefish::GetInstance() + i);
}
bool is_first_instance = true;
for (const auto& num : instance_nums) {
auto instance = tmp_config_obj.ForInstance(num);
- auto const_instance = const_cast<const vsoc::CuttlefishConfig&>(tmp_config_obj)
+ auto const_instance = const_cast<const cuttlefish::CuttlefishConfig&>(tmp_config_obj)
.ForInstance(num);
// Set this first so that calls to PerInstancePath below are correct
instance.set_instance_dir(FLAGS_instance_dir + "." + std::to_string(num));
@@ -505,8 +505,8 @@
instance.set_logcat_port(6700 + num - 1);
instance.set_config_server_port(6800 + num - 1);
- if (FLAGS_gpu_mode != vsoc::kGpuModeDrmVirgl &&
- FLAGS_gpu_mode != vsoc::kGpuModeGfxStream) {
+ if (FLAGS_gpu_mode != cuttlefish::kGpuModeDrmVirgl &&
+ FLAGS_gpu_mode != cuttlefish::kGpuModeGfxStream) {
instance.set_frames_server_port(6900 + num - 1);
}
@@ -559,9 +559,9 @@
return tmp_config_obj;
}
-bool SaveConfig(const vsoc::CuttlefishConfig& tmp_config_obj) {
+bool SaveConfig(const cuttlefish::CuttlefishConfig& tmp_config_obj) {
auto config_file = GetConfigFilePath(tmp_config_obj);
- auto config_link = vsoc::GetGlobalConfigFileLink();
+ auto config_link = cuttlefish::GetGlobalConfigFileLink();
// Save the config object before starting any host process
if (!tmp_config_obj.SaveToFile(config_file)) {
LOG(ERROR) << "Unable to save config object";
@@ -574,7 +574,7 @@
return false;
}
}
- setenv(vsoc::kCuttlefishConfigEnvVarName, config_file.c_str(), true);
+ setenv(cuttlefish::kCuttlefishConfigEnvVarName, config_file.c_str(), true);
if (symlink(config_file.c_str(), config_link.c_str()) != 0) {
LOG(ERROR) << "Failed to create symlink to config file at " << config_link
<< ": " << strerror(errno);
@@ -606,12 +606,12 @@
return false;
}
return (::mkdir(var_empty.c_str(), 0755) == 0);
- }(vsoc::kCrosvmVarEmptyDir);
+ }(cuttlefish::kCrosvmVarEmptyDir);
}
// Sepolicy rules need to be updated to support gpu mode. Temporarily disable
// auto-enabling sandbox when gpu is enabled (b/152323505).
- if (FLAGS_gpu_mode != vsoc::kGpuModeGuestSwiftshader) {
+ if (FLAGS_gpu_mode != cuttlefish::kGpuModeGuestSwiftshader) {
default_enable_sandbox = false;
}
@@ -665,7 +665,7 @@
return false;
}
// Set the env variable to empty (in case the caller passed a value for it).
- unsetenv(vsoc::kCuttlefishConfigEnvVarName);
+ unsetenv(cuttlefish::kCuttlefishConfigEnvVarName);
return ResolveInstanceFiles();
}
@@ -758,14 +758,14 @@
return true;
}
-bool CleanPriorFiles(const vsoc::CuttlefishConfig& config, const std::set<std::string>& preserving) {
+bool CleanPriorFiles(const cuttlefish::CuttlefishConfig& config, const std::set<std::string>& preserving) {
std::vector<std::string> paths = {
// Everything in the assembly directory
FLAGS_assembly_dir,
// The environment file
GetCuttlefishEnvPath(),
// The global link to the config file
- vsoc::GetGlobalConfigFileLink(),
+ cuttlefish::GetGlobalConfigFileLink(),
};
for (const auto& instance : config.Instances()) {
paths.push_back(instance.instance_dir());
@@ -775,7 +775,7 @@
}
bool DecompressKernel(const std::string& src, const std::string& dst) {
- cuttlefish::Command decomp_cmd(vsoc::DefaultHostArtifactsPath("bin/extract-vmlinux"));
+ cuttlefish::Command decomp_cmd(cuttlefish::DefaultHostArtifactsPath("bin/extract-vmlinux"));
decomp_cmd.AddParameter(src);
auto output_file = cuttlefish::SharedFD::Creat(dst.c_str(), 0666);
if (!output_file->IsOpen()) {
@@ -788,9 +788,9 @@
return decomp_proc.Started() && decomp_proc.Wait() == 0;
}
-void ValidateAdbModeFlag(const vsoc::CuttlefishConfig& config) {
+void ValidateAdbModeFlag(const cuttlefish::CuttlefishConfig& config) {
auto adb_modes = config.adb_mode();
- adb_modes.erase(vsoc::AdbMode::Unknown);
+ adb_modes.erase(cuttlefish::AdbMode::Unknown);
if (adb_modes.size() < 1) {
LOG(INFO) << "ADB not enabled";
}
@@ -876,7 +876,7 @@
return ret;
}
-bool ShouldCreateCompositeDisk(const vsoc::CuttlefishConfig& config) {
+bool ShouldCreateCompositeDisk(const cuttlefish::CuttlefishConfig& config) {
if (!cuttlefish::FileExists(config.composite_disk_path())) {
return true;
}
@@ -910,7 +910,7 @@
return vfs.f_bsize * vfs.f_bavail; // block size * free blocks for unprivileged users
}
-bool CreateCompositeDisk(const vsoc::CuttlefishConfig& config) {
+bool CreateCompositeDisk(const cuttlefish::CuttlefishConfig& config) {
if (!cuttlefish::SharedFD::Open(config.composite_disk_path().c_str(), O_WRONLY | O_CREAT, 0644)->IsOpen()) {
LOG(ERROR) << "Could not ensure " << config.composite_disk_path() << " exists";
return false;
@@ -954,7 +954,7 @@
# define O_TMPFILE (020000000 | O_DIRECTORY)
#endif
-const vsoc::CuttlefishConfig* InitFilesystemAndCreateConfig(
+const cuttlefish::CuttlefishConfig* InitFilesystemAndCreateConfig(
int* argc, char*** argv, cuttlefish::FetcherConfig fetcher_config) {
if (!ParseCommandLineFlags(argc, argv)) {
LOG(ERROR) << "Failed to parse command arguments";
@@ -1047,7 +1047,7 @@
exit(AssemblerExitCodes::kInstanceDirCreationError);
}
}
- auto internal_dir = instance.instance_dir() + "/" + vsoc::kInternalDirName;
+ auto internal_dir = instance.instance_dir() + "/" + cuttlefish::kInternalDirName;
if (!cuttlefish::DirectoryExists(internal_dir)) {
if (mkdir(internal_dir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) < 0
&& errno != EEXIST) {
@@ -1069,7 +1069,7 @@
}
}
- std::string first_instance = FLAGS_instance_dir + "." + std::to_string(vsoc::GetInstance());
+ std::string first_instance = FLAGS_instance_dir + "." + std::to_string(cuttlefish::GetInstance());
if (symlink(first_instance.c_str(), FLAGS_instance_dir.c_str()) < 0) {
LOG(ERROR) << "Could not symlink \"" << first_instance << "\" to \"" << FLAGS_instance_dir << "\"";
exit(cuttlefish::kCuttlefishConfigurationInitError);
@@ -1086,7 +1086,7 @@
}
// Do this early so that the config object is ready for anything that needs it
- auto config = vsoc::CuttlefishConfig::Get();
+ auto config = cuttlefish::CuttlefishConfig::Get();
if (!config) {
LOG(ERROR) << "Failed to obtain config singleton";
exit(AssemblerExitCodes::kCuttlefishConfigurationInitError);
@@ -1232,6 +1232,6 @@
return config;
}
-std::string GetConfigFilePath(const vsoc::CuttlefishConfig& config) {
+std::string GetConfigFilePath(const cuttlefish::CuttlefishConfig& config) {
return config.AssemblyPath("cuttlefish_config.json");
}
diff --git a/host/commands/assemble_cvd/flags.h b/host/commands/assemble_cvd/flags.h
index da5c5b5..e7e33a7 100644
--- a/host/commands/assemble_cvd/flags.h
+++ b/host/commands/assemble_cvd/flags.h
@@ -3,6 +3,6 @@
#include "host/libs/config/cuttlefish_config.h"
#include "host/libs/config/fetcher_config.h"
-const vsoc::CuttlefishConfig* InitFilesystemAndCreateConfig(
+const cuttlefish::CuttlefishConfig* InitFilesystemAndCreateConfig(
int* argc, char*** argv, cuttlefish::FetcherConfig config);
-std::string GetConfigFilePath(const vsoc::CuttlefishConfig& config);
+std::string GetConfigFilePath(const cuttlefish::CuttlefishConfig& config);
diff --git a/host/commands/assemble_cvd/super_image_mixer.cc b/host/commands/assemble_cvd/super_image_mixer.cc
index b2ce8d8..c626612 100644
--- a/host/commands/assemble_cvd/super_image_mixer.cc
+++ b/host/commands/assemble_cvd/super_image_mixer.cc
@@ -37,7 +37,7 @@
namespace {
using cuttlefish::FileExists;
-using vsoc::DefaultHostArtifactsPath;
+using cuttlefish::DefaultHostArtifactsPath;
std::string TargetFilesZip(const cuttlefish::FetcherConfig& fetcher_config,
cuttlefish::FileSource source) {
@@ -285,7 +285,7 @@
} // namespace
bool SuperImageNeedsRebuilding(const cuttlefish::FetcherConfig& fetcher_config,
- const vsoc::CuttlefishConfig&) {
+ const cuttlefish::CuttlefishConfig&) {
bool has_default_build = false;
bool has_system_build = false;
for (const auto& file_iter : fetcher_config.get_cvd_files()) {
@@ -299,7 +299,7 @@
}
bool RebuildSuperImage(const cuttlefish::FetcherConfig& fetcher_config,
- const vsoc::CuttlefishConfig& config,
+ const cuttlefish::CuttlefishConfig& config,
const std::string& output_path) {
std::string default_target_zip =
TargetFilesZip(fetcher_config, cuttlefish::FileSource::DEFAULT_BUILD);
diff --git a/host/commands/assemble_cvd/super_image_mixer.h b/host/commands/assemble_cvd/super_image_mixer.h
index c612fd5..8360ee4 100644
--- a/host/commands/assemble_cvd/super_image_mixer.h
+++ b/host/commands/assemble_cvd/super_image_mixer.h
@@ -17,7 +17,7 @@
#include "host/libs/config/fetcher_config.h"
bool SuperImageNeedsRebuilding(const cuttlefish::FetcherConfig& fetcher_config,
- const vsoc::CuttlefishConfig& config);
+ const cuttlefish::CuttlefishConfig& config);
bool RebuildSuperImage(const cuttlefish::FetcherConfig& fetcher_config,
- const vsoc::CuttlefishConfig& config,
+ const cuttlefish::CuttlefishConfig& config,
const std::string& output_path);
diff --git a/host/commands/console_forwarder/main.cpp b/host/commands/console_forwarder/main.cpp
index 3ec9d36..468dfd8 100644
--- a/host/commands/console_forwarder/main.cpp
+++ b/host/commands/console_forwarder/main.cpp
@@ -196,7 +196,7 @@
return -2;
}
- auto config = vsoc::CuttlefishConfig::Get();
+ auto config = cuttlefish::CuttlefishConfig::Get();
if (!config) {
LOG(ERROR) << "Unable to get config object";
return -3;
diff --git a/host/commands/cvd_status/cvd_status.cc b/host/commands/cvd_status/cvd_status.cc
index 9a90882..ff6b7a3 100644
--- a/host/commands/cvd_status/cvd_status.cc
+++ b/host/commands/cvd_status/cvd_status.cc
@@ -53,7 +53,7 @@
::android::base::InitLogging(argv, android::base::StderrLogger);
google::ParseCommandLineFlags(&argc, &argv, true);
- auto config = vsoc::CuttlefishConfig::Get();
+ auto config = cuttlefish::CuttlefishConfig::Get();
if (!config) {
LOG(ERROR) << "Failed to obtain config object";
return 1;
diff --git a/host/commands/kernel_log_monitor/kernel_log_server.cc b/host/commands/kernel_log_monitor/kernel_log_server.cc
index 1f4f331..936986f 100644
--- a/host/commands/kernel_log_monitor/kernel_log_server.cc
+++ b/host/commands/kernel_log_monitor/kernel_log_server.cc
@@ -33,12 +33,12 @@
};
static const std::map<std::string, monitor::BootEvent> kStageToEventMap = {
- {vsoc::kBootStartedMessage, monitor::BootEvent::BootStarted},
- {vsoc::kBootCompletedMessage, monitor::BootEvent::BootCompleted},
- {vsoc::kBootFailedMessage, monitor::BootEvent::BootFailed},
- {vsoc::kMobileNetworkConnectedMessage,
+ {cuttlefish::kBootStartedMessage, monitor::BootEvent::BootStarted},
+ {cuttlefish::kBootCompletedMessage, monitor::BootEvent::BootCompleted},
+ {cuttlefish::kBootFailedMessage, monitor::BootEvent::BootFailed},
+ {cuttlefish::kMobileNetworkConnectedMessage,
monitor::BootEvent::MobileNetworkConnected},
- {vsoc::kWifiConnectedMessage, monitor::BootEvent::WifiNetworkConnected},
+ {cuttlefish::kWifiConnectedMessage, monitor::BootEvent::WifiNetworkConnected},
// TODO(b/131864854): Replace this with a string less likely to change
{"init: starting service 'adbd'", monitor::BootEvent::AdbdStarted},
};
diff --git a/host/commands/kernel_log_monitor/main.cc b/host/commands/kernel_log_monitor/main.cc
index 4c4a7ba..9c65b1b 100644
--- a/host/commands/kernel_log_monitor/main.cc
+++ b/host/commands/kernel_log_monitor/main.cc
@@ -64,7 +64,7 @@
cuttlefish::DefaultSubprocessLogging(argv);
google::ParseCommandLineFlags(&argc, &argv, true);
- auto config = vsoc::CuttlefishConfig::Get();
+ auto config = cuttlefish::CuttlefishConfig::Get();
CHECK(config) << "Could not open cuttlefish config";
diff --git a/host/commands/launch/launch_cvd.cc b/host/commands/launch/launch_cvd.cc
index 1a077b4..1833bb9 100644
--- a/host/commands/launch/launch_cvd.cc
+++ b/host/commands/launch/launch_cvd.cc
@@ -45,7 +45,7 @@
DEFINE_string(report_anonymous_usage_stats, "", "Report anonymous usage "
"statistics for metrics collection and analysis.");
DEFINE_int32(base_instance_num,
- vsoc::GetInstance(),
+ cuttlefish::GetInstance(),
"The instance number of the device created. When `-num_instances N`"
" is used, N instance numbers are claimed starting at this number.");
DEFINE_string(verbosity, "INFO", "Console logging verbosity. Options are VERBOSE,"
@@ -53,8 +53,8 @@
namespace {
-std::string kAssemblerBin = vsoc::DefaultHostArtifactsPath("bin/assemble_cvd");
-std::string kRunnerBin = vsoc::DefaultHostArtifactsPath("bin/run_cvd");
+std::string kAssemblerBin = cuttlefish::DefaultHostArtifactsPath("bin/assemble_cvd");
+std::string kRunnerBin = cuttlefish::DefaultHostArtifactsPath("bin/run_cvd");
cuttlefish::Subprocess StartAssembler(cuttlefish::SharedFD assembler_stdin,
cuttlefish::SharedFD assembler_stdout,
@@ -95,12 +95,12 @@
std::string ValidateMetricsConfirmation(std::string use_metrics) {
if (use_metrics == "") {
- if (vsoc::CuttlefishConfig::ConfigExists()) {
- auto config = vsoc::CuttlefishConfig::Get();
+ if (cuttlefish::CuttlefishConfig::ConfigExists()) {
+ auto config = cuttlefish::CuttlefishConfig::Get();
if (config) {
- if (config->enable_metrics() == vsoc::CuttlefishConfig::kYes) {
+ if (config->enable_metrics() == cuttlefish::CuttlefishConfig::kYes) {
use_metrics = "y";
- } else if (config->enable_metrics() == vsoc::CuttlefishConfig::kNo) {
+ } else if (config->enable_metrics() == cuttlefish::CuttlefishConfig::kNo) {
use_metrics = "n";
}
}
diff --git a/host/commands/log_tee/log_tee.cpp b/host/commands/log_tee/log_tee.cpp
index 783329c..1cf502e 100644
--- a/host/commands/log_tee/log_tee.cpp
+++ b/host/commands/log_tee/log_tee.cpp
@@ -30,7 +30,7 @@
CHECK(FLAGS_log_fd_in >= 0) << "-log_fd_in is required";
- auto config = vsoc::CuttlefishConfig::Get();
+ auto config = cuttlefish::CuttlefishConfig::Get();
CHECK(config) << "Could not open cuttlefish config";
diff --git a/host/commands/logcat_receiver/main.cpp b/host/commands/logcat_receiver/main.cpp
index 189e0a0..529ea74 100644
--- a/host/commands/logcat_receiver/main.cpp
+++ b/host/commands/logcat_receiver/main.cpp
@@ -29,7 +29,7 @@
cuttlefish::DefaultSubprocessLogging(argv);
google::ParseCommandLineFlags(&argc, &argv, true);
- auto config = vsoc::CuttlefishConfig::Get();
+ auto config = cuttlefish::CuttlefishConfig::Get();
auto instance = config->ForDefaultInstance();
auto path = instance.logcat_path();
diff --git a/host/commands/metrics/metrics.cc b/host/commands/metrics/metrics.cc
index 3ddeb11..378155c 100644
--- a/host/commands/metrics/metrics.cc
+++ b/host/commands/metrics/metrics.cc
@@ -27,7 +27,7 @@
::android::base::InitLogging(argv, android::base::StderrLogger);
google::ParseCommandLineFlags(&argc, &argv, true);
- auto config = vsoc::CuttlefishConfig::Get();
+ auto config = cuttlefish::CuttlefishConfig::Get();
CHECK(config) << "Could not open cuttlefish config";
@@ -43,7 +43,7 @@
{metrics_log_path, instance.launcher_log_path()}));
}
- if (config->enable_metrics() != vsoc::CuttlefishConfig::kYes) {
+ if (config->enable_metrics() != cuttlefish::CuttlefishConfig::kYes) {
LOG(ERROR) << "metrics not enabled, but metrics were launched.";
return cuttlefish::MetricsExitCodes::kInvalidHostConfiguration;
}
diff --git a/host/commands/run_cvd/launch.cc b/host/commands/run_cvd/launch.cc
index fbe8aa5..ef3a633 100644
--- a/host/commands/run_cvd/launch.cc
+++ b/host/commands/run_cvd/launch.cc
@@ -18,46 +18,46 @@
namespace {
-std::string GetAdbConnectorTcpArg(const vsoc::CuttlefishConfig& config) {
+std::string GetAdbConnectorTcpArg(const cuttlefish::CuttlefishConfig& config) {
auto instance = config.ForDefaultInstance();
return std::string{"127.0.0.1:"} + std::to_string(instance.host_port());
}
-std::string GetAdbConnectorVsockArg(const vsoc::CuttlefishConfig& config) {
+std::string GetAdbConnectorVsockArg(const cuttlefish::CuttlefishConfig& config) {
auto instance = config.ForDefaultInstance();
return std::string{"vsock:"} + std::to_string(instance.vsock_guest_cid()) +
std::string{":5555"};
}
-bool AdbModeEnabled(const vsoc::CuttlefishConfig& config, vsoc::AdbMode mode) {
+bool AdbModeEnabled(const cuttlefish::CuttlefishConfig& config, cuttlefish::AdbMode mode) {
return config.adb_mode().count(mode) > 0;
}
-bool AdbVsockTunnelEnabled(const vsoc::CuttlefishConfig& config) {
+bool AdbVsockTunnelEnabled(const cuttlefish::CuttlefishConfig& config) {
auto instance = config.ForDefaultInstance();
return instance.vsock_guest_cid() > 2 &&
- AdbModeEnabled(config, vsoc::AdbMode::VsockTunnel);
+ AdbModeEnabled(config, cuttlefish::AdbMode::VsockTunnel);
}
-bool AdbVsockHalfTunnelEnabled(const vsoc::CuttlefishConfig& config) {
+bool AdbVsockHalfTunnelEnabled(const cuttlefish::CuttlefishConfig& config) {
auto instance = config.ForDefaultInstance();
return instance.vsock_guest_cid() > 2 &&
- AdbModeEnabled(config, vsoc::AdbMode::VsockHalfTunnel);
+ AdbModeEnabled(config, cuttlefish::AdbMode::VsockHalfTunnel);
}
-bool AdbTcpConnectorEnabled(const vsoc::CuttlefishConfig& config) {
+bool AdbTcpConnectorEnabled(const cuttlefish::CuttlefishConfig& config) {
bool vsock_tunnel = AdbVsockTunnelEnabled(config);
bool vsock_half_tunnel = AdbVsockHalfTunnelEnabled(config);
return config.run_adb_connector() && (vsock_tunnel || vsock_half_tunnel);
}
-bool AdbVsockConnectorEnabled(const vsoc::CuttlefishConfig& config) {
+bool AdbVsockConnectorEnabled(const cuttlefish::CuttlefishConfig& config) {
return config.run_adb_connector() &&
- AdbModeEnabled(config, vsoc::AdbMode::NativeVsock);
+ AdbModeEnabled(config, cuttlefish::AdbMode::NativeVsock);
}
cuttlefish::OnSocketReadyCb GetOnSubprocessExitCallback(
- const vsoc::CuttlefishConfig& config) {
+ const cuttlefish::CuttlefishConfig& config) {
if (config.restart_subprocesses()) {
return cuttlefish::ProcessMonitor::RestartOnExitCb;
} else {
@@ -78,7 +78,7 @@
// Creates the frame and input sockets and add the relevant arguments to the vnc
// server and webrtc commands
StreamerLaunchResult CreateStreamerServers(
- cuttlefish::Command* cmd, const vsoc::CuttlefishConfig& config) {
+ cuttlefish::Command* cmd, const cuttlefish::CuttlefishConfig& config) {
StreamerLaunchResult server_ret;
cuttlefish::SharedFD touch_server;
cuttlefish::SharedFD keyboard_server;
@@ -110,8 +110,8 @@
cmd->AddParameter("-keyboard_fd=", keyboard_server);
cuttlefish::SharedFD frames_server;
- if (config.gpu_mode() == vsoc::kGpuModeDrmVirgl ||
- config.gpu_mode() == vsoc::kGpuModeGfxStream) {
+ if (config.gpu_mode() == cuttlefish::kGpuModeDrmVirgl ||
+ config.gpu_mode() == cuttlefish::kGpuModeGfxStream) {
frames_server = CreateUnixInputServer(instance.frames_socket_path());
} else {
frames_server = cuttlefish::SharedFD::VsockServer(instance.frames_server_port(),
@@ -127,12 +127,12 @@
} // namespace
-bool LogcatReceiverEnabled(const vsoc::CuttlefishConfig& config) {
+bool LogcatReceiverEnabled(const cuttlefish::CuttlefishConfig& config) {
return config.logcat_mode() == cuttlefish::kLogcatVsockMode;
}
std::vector<cuttlefish::SharedFD> LaunchKernelLogMonitor(
- const vsoc::CuttlefishConfig& config, cuttlefish::ProcessMonitor* process_monitor,
+ const cuttlefish::CuttlefishConfig& config, cuttlefish::ProcessMonitor* process_monitor,
unsigned int number_of_event_pipes) {
auto instance = config.ForDefaultInstance();
auto log_name = instance.kernel_log_pipe_name();
@@ -176,7 +176,7 @@
return ret;
}
-void LaunchLogcatReceiverIfEnabled(const vsoc::CuttlefishConfig& config,
+void LaunchLogcatReceiverIfEnabled(const cuttlefish::CuttlefishConfig& config,
cuttlefish::ProcessMonitor* process_monitor) {
if (!LogcatReceiverEnabled(config)) {
return;
@@ -196,7 +196,7 @@
return;
}
-void LaunchConfigServer(const vsoc::CuttlefishConfig& config,
+void LaunchConfigServer(const cuttlefish::CuttlefishConfig& config,
cuttlefish::ProcessMonitor* process_monitor) {
auto instance = config.ForDefaultInstance();
auto port = instance.config_server_port();
@@ -213,7 +213,7 @@
return;
}
-void LaunchTombstoneReceiverIfEnabled(const vsoc::CuttlefishConfig& config,
+void LaunchTombstoneReceiverIfEnabled(const cuttlefish::CuttlefishConfig& config,
cuttlefish::ProcessMonitor* process_monitor) {
if (!config.enable_tombstone_receiver()) {
return;
@@ -250,7 +250,7 @@
}
StreamerLaunchResult LaunchVNCServer(
- const vsoc::CuttlefishConfig& config, cuttlefish::ProcessMonitor* process_monitor,
+ const cuttlefish::CuttlefishConfig& config, cuttlefish::ProcessMonitor* process_monitor,
std::function<bool(MonitorEntry*)> callback) {
auto instance = config.ForDefaultInstance();
// Launch the vnc server, don't wait for it to complete
@@ -266,7 +266,7 @@
}
void LaunchAdbConnectorIfEnabled(cuttlefish::ProcessMonitor* process_monitor,
- const vsoc::CuttlefishConfig& config,
+ const cuttlefish::CuttlefishConfig& config,
cuttlefish::SharedFD adbd_events_pipe) {
cuttlefish::Command adb_connector(config.adb_connector_binary());
adb_connector.AddParameter("-adbd_events_fd=", adbd_events_pipe);
@@ -292,7 +292,7 @@
}
StreamerLaunchResult LaunchWebRTC(cuttlefish::ProcessMonitor* process_monitor,
- const vsoc::CuttlefishConfig& config) {
+ const cuttlefish::CuttlefishConfig& config) {
if (config.ForDefaultInstance().start_webrtc_sig_server()) {
cuttlefish::Command sig_server(config.sig_server_binary());
sig_server.AddParameter("-assets_dir=", config.webrtc_assets_dir());
@@ -331,7 +331,7 @@
}
void LaunchSocketVsockProxyIfEnabled(cuttlefish::ProcessMonitor* process_monitor,
- const vsoc::CuttlefishConfig& config) {
+ const cuttlefish::CuttlefishConfig& config) {
auto instance = config.ForDefaultInstance();
if (AdbVsockTunnelEnabled(config)) {
cuttlefish::Command adb_tunnel(config.socket_vsock_proxy_binary());
@@ -358,12 +358,12 @@
}
void LaunchTpmSimulator(cuttlefish::ProcessMonitor* process_monitor,
- const vsoc::CuttlefishConfig& config) {
+ const cuttlefish::CuttlefishConfig& config) {
auto instance = config.ForDefaultInstance();
auto port = instance.tpm_port();
auto socket = cuttlefish::SharedFD::VsockServer(port, SOCK_STREAM);
cuttlefish::Command tpm_command(
- vsoc::DefaultHostArtifactsPath("bin/tpm_simulator_manager"));
+ cuttlefish::DefaultHostArtifactsPath("bin/tpm_simulator_manager"));
tpm_command.AddParameter("-port=", port);
process_monitor->StartSubprocess(std::move(tpm_command),
GetOnSubprocessExitCallback(config));
@@ -377,7 +377,7 @@
}
void LaunchMetrics(cuttlefish::ProcessMonitor* process_monitor,
- const vsoc::CuttlefishConfig& config) {
+ const cuttlefish::CuttlefishConfig& config) {
cuttlefish::Command metrics(config.metrics_binary());
process_monitor->StartSubprocess(std::move(metrics),
@@ -385,7 +385,7 @@
}
void LaunchTpmPassthrough(cuttlefish::ProcessMonitor* process_monitor,
- const vsoc::CuttlefishConfig& config) {
+ const cuttlefish::CuttlefishConfig& config) {
auto server = cuttlefish::SharedFD::VsockServer(SOCK_STREAM);
if (!server->IsOpen()) {
LOG(ERROR) << "Unable to create tpm passthrough server: "
@@ -393,7 +393,7 @@
std::exit(RunnerExitCodes::kTpmPassthroughError);
}
cuttlefish::Command tpm_command(
- vsoc::DefaultHostArtifactsPath("bin/vtpm_passthrough"));
+ cuttlefish::DefaultHostArtifactsPath("bin/vtpm_passthrough"));
tpm_command.AddParameter("-server_fd=", server);
tpm_command.AddParameter("-device=", config.tpm_device());
@@ -402,7 +402,7 @@
}
void LaunchTpm(cuttlefish::ProcessMonitor* process_monitor,
- const vsoc::CuttlefishConfig& config) {
+ const cuttlefish::CuttlefishConfig& config) {
if (config.tpm_device() != "") {
if (config.tpm_binary() != "") {
LOG(WARNING)
@@ -415,10 +415,10 @@
}
void LaunchSecureEnvironment(cuttlefish::ProcessMonitor* process_monitor,
- const vsoc::CuttlefishConfig& config) {
+ const cuttlefish::CuttlefishConfig& config) {
auto port = config.ForDefaultInstance().keymaster_vsock_port();
auto server = cuttlefish::SharedFD::VsockServer(port, SOCK_STREAM);
- cuttlefish::Command command(vsoc::DefaultHostArtifactsPath("bin/secure_env"));
+ cuttlefish::Command command(cuttlefish::DefaultHostArtifactsPath("bin/secure_env"));
command.AddParameter("-keymaster_fd=", server);
process_monitor->StartSubprocess(std::move(command),
GetOnSubprocessExitCallback(config));
diff --git a/host/commands/run_cvd/launch.h b/host/commands/run_cvd/launch.h
index 42bd5bc..d785c27 100644
--- a/host/commands/run_cvd/launch.h
+++ b/host/commands/run_cvd/launch.h
@@ -10,38 +10,38 @@
#include "host/libs/config/cuttlefish_config.h"
std::vector <cuttlefish::SharedFD> LaunchKernelLogMonitor(
- const vsoc::CuttlefishConfig& config,
+ const cuttlefish::CuttlefishConfig& config,
cuttlefish::ProcessMonitor* process_monitor,
unsigned int number_of_event_pipes);
void LaunchAdbConnectorIfEnabled(cuttlefish::ProcessMonitor* process_monitor,
- const vsoc::CuttlefishConfig& config,
+ const cuttlefish::CuttlefishConfig& config,
cuttlefish::SharedFD adbd_events_pipe);
void LaunchSocketVsockProxyIfEnabled(cuttlefish::ProcessMonitor* process_monitor,
- const vsoc::CuttlefishConfig& config);
+ const cuttlefish::CuttlefishConfig& config);
struct StreamerLaunchResult {
bool launched = false;
};
StreamerLaunchResult LaunchVNCServer(
- const vsoc::CuttlefishConfig& config,
+ const cuttlefish::CuttlefishConfig& config,
cuttlefish::ProcessMonitor* process_monitor,
std::function<bool(cuttlefish::MonitorEntry*)> callback);
-void LaunchTombstoneReceiverIfEnabled(const vsoc::CuttlefishConfig& config,
+void LaunchTombstoneReceiverIfEnabled(const cuttlefish::CuttlefishConfig& config,
cuttlefish::ProcessMonitor* process_monitor);
-void LaunchLogcatReceiverIfEnabled(const vsoc::CuttlefishConfig& config,
+void LaunchLogcatReceiverIfEnabled(const cuttlefish::CuttlefishConfig& config,
cuttlefish::ProcessMonitor* process_monitor);
-void LaunchConfigServer(const vsoc::CuttlefishConfig& config,
+void LaunchConfigServer(const cuttlefish::CuttlefishConfig& config,
cuttlefish::ProcessMonitor* process_monitor);
StreamerLaunchResult LaunchWebRTC(cuttlefish::ProcessMonitor* process_monitor,
- const vsoc::CuttlefishConfig& config);
+ const cuttlefish::CuttlefishConfig& config);
void LaunchTpm(cuttlefish::ProcessMonitor* process_monitor,
- const vsoc::CuttlefishConfig& config);
+ const cuttlefish::CuttlefishConfig& config);
void LaunchMetrics(cuttlefish::ProcessMonitor* process_monitor,
- const vsoc::CuttlefishConfig& config);
+ const cuttlefish::CuttlefishConfig& config);
void LaunchSecureEnvironment(cuttlefish::ProcessMonitor* process_monitor,
- const vsoc::CuttlefishConfig& config);
+ const cuttlefish::CuttlefishConfig& config);
diff --git a/host/commands/run_cvd/main.cc b/host/commands/run_cvd/main.cc
index 5d350a6..6667f43 100644
--- a/host/commands/run_cvd/main.cc
+++ b/host/commands/run_cvd/main.cc
@@ -58,13 +58,13 @@
#include "host/libs/vm_manager/vm_manager.h"
#include "host/libs/vm_manager/qemu_manager.h"
-using vsoc::ForCurrentInstance;
+using cuttlefish::ForCurrentInstance;
using cuttlefish::RunnerExitCodes;
namespace {
cuttlefish::OnSocketReadyCb GetOnSubprocessExitCallback(
- const vsoc::CuttlefishConfig& config) {
+ const cuttlefish::CuttlefishConfig& config) {
if (config.restart_subprocesses()) {
return cuttlefish::ProcessMonitor::RestartOnExitCb;
} else {
@@ -152,7 +152,7 @@
});
}
-bool WriteCuttlefishEnvironment(const vsoc::CuttlefishConfig& config) {
+bool WriteCuttlefishEnvironment(const cuttlefish::CuttlefishConfig& config) {
auto env = cuttlefish::SharedFD::Open(config.cuttlefish_env_path().c_str(),
O_CREAT | O_RDWR, 0755);
if (!env->IsOpen()) {
@@ -169,7 +169,7 @@
// Forks and returns the write end of a pipe to the child process. The parent
// process waits for boot events to come through the pipe and exits accordingly.
-cuttlefish::SharedFD DaemonizeLauncher(const vsoc::CuttlefishConfig& config) {
+cuttlefish::SharedFD DaemonizeLauncher(const cuttlefish::CuttlefishConfig& config) {
auto instance = config.ForDefaultInstance();
cuttlefish::SharedFD read_end, write_end;
if (!cuttlefish::SharedFD::Pipe(&read_end, &write_end)) {
@@ -195,9 +195,9 @@
LOG(ERROR) << "Unexpected exit code: " << exit_code;
}
if (exit_code == RunnerExitCodes::kSuccess) {
- LOG(INFO) << vsoc::kBootCompletedMessage;
+ LOG(INFO) << cuttlefish::kBootCompletedMessage;
} else {
- LOG(INFO) << vsoc::kBootFailedMessage;
+ LOG(INFO) << cuttlefish::kBootFailedMessage;
}
std::exit(exit_code);
} else {
@@ -275,7 +275,7 @@
}
}
-std::string GetConfigFilePath(const vsoc::CuttlefishConfig& config) {
+std::string GetConfigFilePath(const cuttlefish::CuttlefishConfig& config) {
auto instance = config.ForDefaultInstance();
return instance.PerInstancePath("cuttlefish_config.json");
}
@@ -313,14 +313,14 @@
for (const auto& file : input_files) {
if (file.find("cuttlefish_config.json") != std::string::npos) {
found_config = true;
- setenv(vsoc::kCuttlefishConfigEnvVarName, file.c_str(), /* overwrite */ false);
+ setenv(cuttlefish::kCuttlefishConfigEnvVarName, file.c_str(), /* overwrite */ false);
}
}
if (!found_config) {
return RunnerExitCodes::kCuttlefishConfigurationInitError;
}
- auto config = vsoc::CuttlefishConfig::Get();
+ auto config = cuttlefish::CuttlefishConfig::Get();
auto instance = config->ForDefaultInstance();
auto log_path = instance.launcher_log_path();
@@ -415,7 +415,7 @@
// Monitor and restart host processes supporting the CVD
cuttlefish::ProcessMonitor process_monitor;
- if (config->enable_metrics() == vsoc::CuttlefishConfig::kYes) {
+ if (config->enable_metrics() == cuttlefish::CuttlefishConfig::kYes) {
LaunchMetrics(&process_monitor, *config);
}
diff --git a/host/commands/run_cvd/pre_launch_initializers.h b/host/commands/run_cvd/pre_launch_initializers.h
index 79f6eed..6ab7788 100644
--- a/host/commands/run_cvd/pre_launch_initializers.h
+++ b/host/commands/run_cvd/pre_launch_initializers.h
@@ -24,11 +24,11 @@
// machine is started.
// To add initializers for more regions declare here, implement in its own
// source file and call from PreLaunchInitializers::Initialize().
-void InitializeScreenRegion(const vsoc::CuttlefishConfig& config);
+void InitializeScreenRegion(const cuttlefish::CuttlefishConfig& config);
class PreLaunchInitializers {
public:
- static void Initialize(const vsoc::CuttlefishConfig& config) {
+ static void Initialize(const cuttlefish::CuttlefishConfig& config) {
InitializeScreenRegion(config);
}
};
diff --git a/host/commands/stop_cvd/main.cc b/host/commands/stop_cvd/main.cc
index ad0b524..808eaf4 100644
--- a/host/commands/stop_cvd/main.cc
+++ b/host/commands/stop_cvd/main.cc
@@ -73,13 +73,13 @@
// Add files in the tombstone directory
paths.insert(instance_dir + "/tombstones/*");
// Add files in the internal directory
- paths.insert(instance_dir + "/" + std::string(vsoc::kInternalDirName) + "/*");
+ paths.insert(instance_dir + "/" + std::string(cuttlefish::kInternalDirName) + "/*");
}
return paths;
}
-std::set<std::string> PathsForInstance(const vsoc::CuttlefishConfig& config,
- const vsoc::CuttlefishConfig::InstanceSpecific instance) {
+std::set<std::string> PathsForInstance(const cuttlefish::CuttlefishConfig& config,
+ const cuttlefish::CuttlefishConfig::InstanceSpecific instance) {
return {
config.assembly_dir(),
config.assembly_dir() + "/*",
@@ -138,7 +138,7 @@
return exit_code;
}
-bool CleanStopInstance(const vsoc::CuttlefishConfig::InstanceSpecific& instance) {
+bool CleanStopInstance(const cuttlefish::CuttlefishConfig::InstanceSpecific& instance) {
auto monitor_path = instance.launcher_monitor_socket_path();
if (monitor_path.empty()) {
LOG(ERROR) << "No path to launcher monitor found";
@@ -189,8 +189,8 @@
return true;
}
-int StopInstance(const vsoc::CuttlefishConfig& config,
- const vsoc::CuttlefishConfig::InstanceSpecific& instance) {
+int StopInstance(const cuttlefish::CuttlefishConfig& config,
+ const cuttlefish::CuttlefishConfig::InstanceSpecific& instance) {
bool res = CleanStopInstance(instance);
if (!res) {
return FallBackStop(PathsForInstance(config, instance));
@@ -204,7 +204,7 @@
::android::base::InitLogging(argv, android::base::StderrLogger);
google::ParseCommandLineFlags(&argc, &argv, true);
- auto config = vsoc::CuttlefishConfig::Get();
+ auto config = cuttlefish::CuttlefishConfig::Get();
if (!config) {
LOG(ERROR) << "Failed to obtain config object";
return FallBackStop(FallbackPaths());
diff --git a/host/commands/tpm_simulator_manager/tpm_simulator_manager.cpp b/host/commands/tpm_simulator_manager/tpm_simulator_manager.cpp
index 238b092..957586b 100644
--- a/host/commands/tpm_simulator_manager/tpm_simulator_manager.cpp
+++ b/host/commands/tpm_simulator_manager/tpm_simulator_manager.cpp
@@ -47,7 +47,7 @@
google::ParseCommandLineFlags(&argc, &argv, true);
CHECK(FLAGS_port > 0) << "A port must be set";
- auto config = vsoc::CuttlefishConfig::Get();
+ auto config = cuttlefish::CuttlefishConfig::Get();
CHECK(config) << "Unable to get config object";
// Assumes linked on the host with glibc
diff --git a/host/frontend/gcastv2/libsource/AudioSource.cpp b/host/frontend/gcastv2/libsource/AudioSource.cpp
index 101d4fc..17722a9 100644
--- a/host/frontend/gcastv2/libsource/AudioSource.cpp
+++ b/host/frontend/gcastv2/libsource/AudioSource.cpp
@@ -771,7 +771,7 @@
uint8_t buffer[4096];
struct timespec absTimeLimit;
- vsoc::RegionView::GetFutureTime(
+ cuttlefish::RegionView::GetFutureTime(
1000000000ll ns_from_now, &absTimeLimit);
intptr_t res = mRegionView->data()->audio_queue.Read(
diff --git a/host/frontend/gcastv2/libsource/include/source/AudioSource.h b/host/frontend/gcastv2/libsource/include/source/AudioSource.h
index 7c7771e..bd2e4b1 100644
--- a/host/frontend/gcastv2/libsource/include/source/AudioSource.h
+++ b/host/frontend/gcastv2/libsource/include/source/AudioSource.h
@@ -23,7 +23,7 @@
#define SIMULATE_AUDIO 0
-namespace vsoc {
+namespace cuttlefish {
class RegionWorker;
namespace audio_data {
class AudioDataRegionView;
@@ -33,7 +33,7 @@
namespace android {
struct AudioSource : public StreamingSource {
- using AudioDataRegionView = vsoc::audio_data::AudioDataRegionView;
+ using AudioDataRegionView = cuttlefish::audio_data::AudioDataRegionView;
enum class Format {
OPUS,
diff --git a/host/frontend/gcastv2/webrtc/ServerState.cpp b/host/frontend/gcastv2/webrtc/ServerState.cpp
index 82ed684..bd09364 100644
--- a/host/frontend/gcastv2/webrtc/ServerState.cpp
+++ b/host/frontend/gcastv2/webrtc/ServerState.cpp
@@ -38,7 +38,7 @@
mRunLoop(runLoop),
mVideoFormat(videoFormat) {
- auto config = vsoc::CuttlefishConfig::Get();
+ auto config = cuttlefish::CuttlefishConfig::Get();
android::FrameBufferSource::Format fbSourceFormat;
switch (videoFormat) {
diff --git a/host/frontend/gcastv2/webrtc/client_handler.cpp b/host/frontend/gcastv2/webrtc/client_handler.cpp
index 9eff97c..96f2f4b 100644
--- a/host/frontend/gcastv2/webrtc/client_handler.cpp
+++ b/host/frontend/gcastv2/webrtc/client_handler.cpp
@@ -73,7 +73,7 @@
std::shared_ptr<AdbHandler> ClientHandler::adb_handler() {
if (!adb_handler_) {
- auto config = vsoc::CuttlefishConfig::Get();
+ auto config = cuttlefish::CuttlefishConfig::Get();
adb_handler_.reset(
new AdbHandler(mRunLoop, config->ForDefaultInstance().adb_ip_and_port(),
[this](const uint8_t *msg, size_t length) {
diff --git a/host/frontend/gcastv2/webrtc/sig_server_handler.cpp b/host/frontend/gcastv2/webrtc/sig_server_handler.cpp
index 9b2b6c4..60a0a79 100644
--- a/host/frontend/gcastv2/webrtc/sig_server_handler.cpp
+++ b/host/frontend/gcastv2/webrtc/sig_server_handler.cpp
@@ -170,7 +170,7 @@
}
void SigServerHandler::OnOpen() {
- auto config = vsoc::CuttlefishConfig::Get();
+ auto config = cuttlefish::CuttlefishConfig::Get();
Json::Value register_obj;
register_obj[cuttlefish::webrtc_signaling::kTypeField] =
cuttlefish::webrtc_signaling::kRegisterType;
diff --git a/host/frontend/gcastv2/webrtc/webRTC.cpp b/host/frontend/gcastv2/webrtc/webRTC.cpp
index d189f30..c0ad5f0 100644
--- a/host/frontend/gcastv2/webrtc/webRTC.cpp
+++ b/host/frontend/gcastv2/webrtc/webRTC.cpp
@@ -59,7 +59,7 @@
SSLSocket::Init();
DTLS::Init();
- auto config = vsoc::CuttlefishConfig::Get();
+ auto config = cuttlefish::CuttlefishConfig::Get();
auto sig_server_addr = config->sig_server_address();
auto sig_server_port = config->sig_server_port();
diff --git a/host/frontend/vnc_server/vnc_client_connection.cpp b/host/frontend/vnc_server/vnc_client_connection.cpp
index 7e9b6df..e414600 100644
--- a/host/frontend/vnc_server/vnc_client_connection.cpp
+++ b/host/frontend/vnc_server/vnc_client_connection.cpp
@@ -88,7 +88,7 @@
constexpr size_t kClientCutTextLength = 7; // more bytes follow
std::string HostName() {
- auto config = vsoc::CuttlefishConfig::Get();
+ auto config = cuttlefish::CuttlefishConfig::Get();
auto instance = config->ForDefaultInstance();
return !config || instance.device_title().empty() ? std::string{"localhost"}
: instance.device_title();
diff --git a/host/libs/config/cuttlefish_config.cpp b/host/libs/config/cuttlefish_config.cpp
index 2948acd..6619be0 100644
--- a/host/libs/config/cuttlefish_config.cpp
+++ b/host/libs/config/cuttlefish_config.cpp
@@ -47,13 +47,13 @@
// Try to get it from the user instead
instance_str = std::getenv("USER");
- if (!instance_str || std::strncmp(instance_str, vsoc::kVsocUserPrefix,
- sizeof(vsoc::kVsocUserPrefix) - 1)) {
+ if (!instance_str || std::strncmp(instance_str, cuttlefish::kVsocUserPrefix,
+ sizeof(cuttlefish::kVsocUserPrefix) - 1)) {
// No user or we don't recognize this user
LOG(DEBUG) << "No user or non-vsoc user, returning default config";
return kDefaultInstance;
}
- instance_str += sizeof(vsoc::kVsocUserPrefix) - 1;
+ instance_str += sizeof(cuttlefish::kVsocUserPrefix) - 1;
// Set the environment variable so that child processes see it
setenv(kInstanceEnvironmentVariable, instance_str, 0);
@@ -185,7 +185,7 @@
const char* kWifiMacAddress = "wifi_mac_address";
} // namespace
-namespace vsoc {
+namespace cuttlefish {
const char* const kGpuModeGuestSwiftshader = "guest_swiftshader";
const char* const kGpuModeDrmVirgl = "drm_virgl";
@@ -1073,7 +1073,7 @@
// Returns nullptr if there was an error loading from file
/*static*/ CuttlefishConfig* CuttlefishConfig::BuildConfigImpl() {
auto config_file_path = cuttlefish::StringFromEnv(kCuttlefishConfigEnvVarName,
- vsoc::GetGlobalConfigFileLink());
+ cuttlefish::GetGlobalConfigFileLink());
auto ret = new CuttlefishConfig();
if (ret) {
auto loaded = ret->LoadFromFile(config_file_path.c_str());
@@ -1092,7 +1092,7 @@
/*static*/ bool CuttlefishConfig::ConfigExists() {
auto config_file_path = cuttlefish::StringFromEnv(kCuttlefishConfigEnvVarName,
- vsoc::GetGlobalConfigFileLink());
+ cuttlefish::GetGlobalConfigFileLink());
auto real_file_path = cuttlefish::AbsolutePath(config_file_path.c_str());
return cuttlefish::FileExists(real_file_path);
}
@@ -1197,7 +1197,7 @@
int GetDefaultPerInstanceVsockCid() {
constexpr int kFirstGuestCid = 3;
- return vsoc::HostSupportsVsock() ? ForCurrentInstance(kFirstGuestCid) : 0;
+ return cuttlefish::HostSupportsVsock() ? ForCurrentInstance(kFirstGuestCid) : 0;
}
std::string DefaultHostArtifactsPath(const std::string& file_name) {
@@ -1226,4 +1226,4 @@
"/usr/lib/cuttlefish-common/bin/capability_query.py vsock") == 0;
return supported;
}
-} // namespace vsoc
+} // namespace cuttlefish
diff --git a/host/libs/config/cuttlefish_config.h b/host/libs/config/cuttlefish_config.h
index 244a917..2bce548 100644
--- a/host/libs/config/cuttlefish_config.h
+++ b/host/libs/config/cuttlefish_config.h
@@ -30,7 +30,7 @@
constexpr char kLogcatVsockMode[] = "vsock";
}
-namespace vsoc {
+namespace cuttlefish {
constexpr char kDefaultUuidPrefix[] = "699acfc4-c8c4-11e7-882b-5065f31dc1";
constexpr char kCuttlefishConfigEnvVarName[] = "CUTTLEFISH_CONFIG_FILE";
@@ -494,4 +494,4 @@
extern const char* const kGpuModeGuestSwiftshader;
extern const char* const kGpuModeDrmVirgl;
extern const char* const kGpuModeGfxStream;
-} // namespace vsoc
+} // namespace cuttlefish
diff --git a/host/libs/config/kernel_args.cpp b/host/libs/config/kernel_args.cpp
index f640c36..9331702 100644
--- a/host/libs/config/kernel_args.cpp
+++ b/host/libs/config/kernel_args.cpp
@@ -45,7 +45,7 @@
return stream.str();
}
-std::vector<std::string> KernelCommandLineFromConfig(const vsoc::CuttlefishConfig& config) {
+std::vector<std::string> KernelCommandLineFromConfig(const cuttlefish::CuttlefishConfig& config) {
auto instance = config.ForDefaultInstance();
std::vector<std::string> kernel_cmdline;
diff --git a/host/libs/config/kernel_args.h b/host/libs/config/kernel_args.h
index 9a0feb7..5d4b396 100644
--- a/host/libs/config/kernel_args.h
+++ b/host/libs/config/kernel_args.h
@@ -21,4 +21,4 @@
#include "host/libs/config/cuttlefish_config.h"
-std::vector<std::string> KernelCommandLineFromConfig(const vsoc::CuttlefishConfig& config);
+std::vector<std::string> KernelCommandLineFromConfig(const cuttlefish::CuttlefishConfig& config);
diff --git a/host/libs/config/logging.cpp b/host/libs/config/logging.cpp
index c56a31c..95085d6 100644
--- a/host/libs/config/logging.cpp
+++ b/host/libs/config/logging.cpp
@@ -27,7 +27,7 @@
void DefaultSubprocessLogging(char* argv[]) {
::android::base::InitLogging(argv, android::base::StderrLogger);
- auto config = vsoc::CuttlefishConfig::Get();
+ auto config = cuttlefish::CuttlefishConfig::Get();
CHECK(config) << "Could not open cuttlefish config";
diff --git a/host/libs/screen_connector/screen_connector.cpp b/host/libs/screen_connector/screen_connector.cpp
index f5eae7e..91bd0c4 100644
--- a/host/libs/screen_connector/screen_connector.cpp
+++ b/host/libs/screen_connector/screen_connector.cpp
@@ -25,11 +25,11 @@
namespace cuttlefish {
ScreenConnector* ScreenConnector::Get(int frames_fd) {
- auto config = vsoc::CuttlefishConfig::Get();
- if (config->gpu_mode() == vsoc::kGpuModeDrmVirgl ||
- config->gpu_mode() == vsoc::kGpuModeGfxStream) {
+ auto config = cuttlefish::CuttlefishConfig::Get();
+ if (config->gpu_mode() == cuttlefish::kGpuModeDrmVirgl ||
+ config->gpu_mode() == cuttlefish::kGpuModeGfxStream) {
return new WaylandScreenConnector(frames_fd);
- } else if (config->gpu_mode() == vsoc::kGpuModeGuestSwiftshader) {
+ } else if (config->gpu_mode() == cuttlefish::kGpuModeGuestSwiftshader) {
return new SocketBasedScreenConnector(frames_fd);
} else {
LOG(ERROR) << "Invalid gpu mode: " << config->gpu_mode();
diff --git a/host/libs/screen_connector/screen_connector.h b/host/libs/screen_connector/screen_connector.h
index 5e0f5cd..68df5eb 100644
--- a/host/libs/screen_connector/screen_connector.h
+++ b/host/libs/screen_connector/screen_connector.h
@@ -43,11 +43,11 @@
}
static inline int ScreenHeight() {
- return vsoc::CuttlefishConfig::Get()->y_res();
+ return cuttlefish::CuttlefishConfig::Get()->y_res();
}
static inline int ScreenWidth() {
- return vsoc::CuttlefishConfig::Get()->x_res();
+ return cuttlefish::CuttlefishConfig::Get()->x_res();
}
static inline int ScreenStride() {
diff --git a/host/libs/vm_manager/crosvm_manager.cpp b/host/libs/vm_manager/crosvm_manager.cpp
index da7679a..08910f6 100644
--- a/host/libs/vm_manager/crosvm_manager.cpp
+++ b/host/libs/vm_manager/crosvm_manager.cpp
@@ -37,7 +37,7 @@
namespace {
-std::string GetControlSocketPath(const vsoc::CuttlefishConfig* config) {
+std::string GetControlSocketPath(const cuttlefish::CuttlefishConfig* config) {
return config->ForDefaultInstance()
.PerInstanceInternalPath("crosvm_control.sock");
}
@@ -63,7 +63,7 @@
bool success = true;
auto dhcp_leases = cuttlefish::ParseDnsmasqLeases(lease_file_fd);
for (auto& lease : dhcp_leases) {
- std::uint8_t dhcp_server_ip[] = {192, 168, 96, (std::uint8_t) (vsoc::ForCurrentInstance(1) * 4 - 3)};
+ std::uint8_t dhcp_server_ip[] = {192, 168, 96, (std::uint8_t) (cuttlefish::ForCurrentInstance(1) * 4 - 3)};
if (!cuttlefish::ReleaseDhcp4(tap_fd, lease.mac_address, lease.ip_address, dhcp_server_ip)) {
LOG(ERROR) << "Failed to release " << lease;
success = false;
@@ -75,7 +75,7 @@
}
bool Stop() {
- auto config = vsoc::CuttlefishConfig::Get();
+ auto config = cuttlefish::CuttlefishConfig::Get();
cuttlefish::Command command(config->crosvm_binary());
command.AddParameter("stop");
command.AddParameter(GetControlSocketPath(config));
@@ -94,7 +94,7 @@
// the HAL search path allows for fallbacks, and fallbacks in conjunction
// with properities lead to non-deterministic behavior while loading the
// HALs.
- if (gpu_mode == vsoc::kGpuModeGuestSwiftshader) {
+ if (gpu_mode == cuttlefish::kGpuModeGuestSwiftshader) {
return {
"androidboot.hardware.gralloc=cutf_ashmem",
"androidboot.hardware.hwcomposer=cutf_hwc2",
@@ -111,14 +111,14 @@
modprobe_cmd.AddParameter("--modeset");
modprobe_cmd.Start().Wait();
- if (gpu_mode == vsoc::kGpuModeDrmVirgl) {
+ if (gpu_mode == cuttlefish::kGpuModeDrmVirgl) {
return {
"androidboot.hardware.gralloc=minigbm",
"androidboot.hardware.hwcomposer=drm_minigbm",
"androidboot.hardware.egl=mesa",
};
}
- if (gpu_mode == vsoc::kGpuModeGfxStream) {
+ if (gpu_mode == cuttlefish::kGpuModeGfxStream) {
return {
"androidboot.hardware.gralloc=minigbm",
"androidboot.hardware.hwcomposer=drm_minigbm",
@@ -140,7 +140,7 @@
}
}
-CrosvmManager::CrosvmManager(const vsoc::CuttlefishConfig* config)
+CrosvmManager::CrosvmManager(const cuttlefish::CuttlefishConfig* config)
: VmManager(config) {}
std::vector<cuttlefish::Command> CrosvmManager::StartCommands() {
@@ -157,9 +157,9 @@
auto gpu_mode = config_->gpu_mode();
- if (gpu_mode == vsoc::kGpuModeDrmVirgl ||
- gpu_mode == vsoc::kGpuModeGfxStream) {
- crosvm_cmd.AddParameter(gpu_mode == vsoc::kGpuModeGfxStream ?
+ if (gpu_mode == cuttlefish::kGpuModeDrmVirgl ||
+ gpu_mode == cuttlefish::kGpuModeGfxStream) {
+ crosvm_cmd.AddParameter(gpu_mode == cuttlefish::kGpuModeGfxStream ?
"--gpu=gfxstream," : "--gpu=",
"width=", config_->x_res(), ",",
"height=", config_->y_res(), ",",
@@ -193,7 +193,7 @@
if (config_->enable_sandbox()) {
const bool seccomp_exists = cuttlefish::DirectoryExists(config_->seccomp_policy_dir());
- const std::string& var_empty_dir = vsoc::kCrosvmVarEmptyDir;
+ const std::string& var_empty_dir = cuttlefish::kCrosvmVarEmptyDir;
const bool var_empty_available = cuttlefish::DirectoryExists(var_empty_dir);
if (!var_empty_available || !seccomp_exists) {
LOG(FATAL) << var_empty_dir << " is not an existing, empty directory."
@@ -263,7 +263,7 @@
crosvm_cmd.RedirectStdIO(cuttlefish::Subprocess::StdIOChannel::kStdErr,
log_out_wr);
- cuttlefish::Command log_tee_cmd(vsoc::DefaultHostArtifactsPath("bin/log_tee"));
+ cuttlefish::Command log_tee_cmd(cuttlefish::DefaultHostArtifactsPath("bin/log_tee"));
log_tee_cmd.AddParameter("--process_name=crosvm");
log_tee_cmd.AddParameter("--log_fd_in=", log_out_rd);
@@ -273,7 +273,7 @@
// TODO(schuffelen): QEMU also needs this and this is not the best place for
// this code. Find a better place to put it.
auto lease_file =
- vsoc::ForCurrentInstance("/var/run/cuttlefish-dnsmasq-cvd-wbr-")
+ cuttlefish::ForCurrentInstance("/var/run/cuttlefish-dnsmasq-cvd-wbr-")
+ ".leases";
if (!ReleaseDhcpLeases(lease_file, wifi_tap)) {
LOG(ERROR) << "Failed to release wifi DHCP leases. Connecting to the wifi "
diff --git a/host/libs/vm_manager/crosvm_manager.h b/host/libs/vm_manager/crosvm_manager.h
index 2ea9993..95bbb9f 100644
--- a/host/libs/vm_manager/crosvm_manager.h
+++ b/host/libs/vm_manager/crosvm_manager.h
@@ -34,7 +34,7 @@
static std::vector<std::string> ConfigureGpu(const std::string& gpu_mode);
static std::vector<std::string> ConfigureBootDevices();
- CrosvmManager(const vsoc::CuttlefishConfig* config);
+ CrosvmManager(const cuttlefish::CuttlefishConfig* config);
virtual ~CrosvmManager() = default;
std::vector<cuttlefish::Command> StartCommands() override;
diff --git a/host/libs/vm_manager/qemu_manager.cpp b/host/libs/vm_manager/qemu_manager.cpp
index f163bd4..61976be 100644
--- a/host/libs/vm_manager/qemu_manager.cpp
+++ b/host/libs/vm_manager/qemu_manager.cpp
@@ -43,7 +43,7 @@
namespace {
-std::string GetMonitorPath(const vsoc::CuttlefishConfig* config) {
+std::string GetMonitorPath(const cuttlefish::CuttlefishConfig* config) {
return config->ForDefaultInstance()
.PerInstanceInternalPath("qemu_monitor.sock");
}
@@ -54,7 +54,7 @@
}
bool Stop() {
- auto config = vsoc::CuttlefishConfig::Get();
+ auto config = cuttlefish::CuttlefishConfig::Get();
auto monitor_path = GetMonitorPath(config);
auto monitor_sock = cuttlefish::SharedFD::SocketLocalClient(
monitor_path.c_str(), false, SOCK_STREAM);
@@ -88,7 +88,7 @@
const std::string QemuManager::name() { return "qemu_cli"; }
std::vector<std::string> QemuManager::ConfigureGpu(const std::string& gpu_mode) {
- if (gpu_mode != vsoc::kGpuModeGuestSwiftshader) {
+ if (gpu_mode != cuttlefish::kGpuModeGuestSwiftshader) {
return {};
}
// Override the default HAL search paths in all cases. We do this because
@@ -109,7 +109,7 @@
return { "androidboot.boot_devices=pci0000:00/0000:00:03.0" };
}
-QemuManager::QemuManager(const vsoc::CuttlefishConfig* config)
+QemuManager::QemuManager(const cuttlefish::CuttlefishConfig* config)
: VmManager(config) {}
std::vector<cuttlefish::Command> QemuManager::StartCommands() {
diff --git a/host/libs/vm_manager/qemu_manager.h b/host/libs/vm_manager/qemu_manager.h
index a1cbaab..cb851ee 100644
--- a/host/libs/vm_manager/qemu_manager.h
+++ b/host/libs/vm_manager/qemu_manager.h
@@ -32,7 +32,7 @@
static std::vector<std::string> ConfigureGpu(const std::string& gpu_mode);
static std::vector<std::string> ConfigureBootDevices();
- QemuManager(const vsoc::CuttlefishConfig* config);
+ QemuManager(const cuttlefish::CuttlefishConfig* config);
virtual ~QemuManager() = default;
std::vector<cuttlefish::Command> StartCommands() override;
diff --git a/host/libs/vm_manager/vm_manager.cpp b/host/libs/vm_manager/vm_manager.cpp
index df44106..26e2122 100644
--- a/host/libs/vm_manager/vm_manager.cpp
+++ b/host/libs/vm_manager/vm_manager.cpp
@@ -28,12 +28,12 @@
namespace vm_manager {
-VmManager::VmManager(const vsoc::CuttlefishConfig* config)
+VmManager::VmManager(const cuttlefish::CuttlefishConfig* config)
: config_(config) {}
namespace{
template <typename T>
-VmManager* GetManagerSingleton(const vsoc::CuttlefishConfig* config) {
+VmManager* GetManagerSingleton(const cuttlefish::CuttlefishConfig* config) {
static std::shared_ptr<VmManager> vm_manager(new T(config));
return vm_manager.get();
}
@@ -45,7 +45,7 @@
QemuManager::name(),
{
GetManagerSingleton<QemuManager>,
- vsoc::HostSupportsQemuCli,
+ cuttlefish::HostSupportsQemuCli,
QemuManager::ConfigureGpu,
QemuManager::ConfigureBootDevices,
},
@@ -55,7 +55,7 @@
{
GetManagerSingleton<CrosvmManager>,
// Same as Qemu for the time being
- vsoc::HostSupportsQemuCli,
+ cuttlefish::HostSupportsQemuCli,
CrosvmManager::ConfigureGpu,
CrosvmManager::ConfigureBootDevices,
}
@@ -63,7 +63,7 @@
};
VmManager* VmManager::Get(const std::string& vm_manager_name,
- const vsoc::CuttlefishConfig* config) {
+ const cuttlefish::CuttlefishConfig* config) {
if (VmManager::IsValidName(vm_manager_name)) {
return vm_manager_helpers_[vm_manager_name].builder(config);
}
diff --git a/host/libs/vm_manager/vm_manager.h b/host/libs/vm_manager/vm_manager.h
index 33995b2..c70a768 100644
--- a/host/libs/vm_manager/vm_manager.h
+++ b/host/libs/vm_manager/vm_manager.h
@@ -34,7 +34,7 @@
// if the requested vm manager is not supported by the current version of the
// host packages
static VmManager* Get(const std::string& vm_manager_name,
- const vsoc::CuttlefishConfig* config);
+ const cuttlefish::CuttlefishConfig* config);
static bool IsValidName(const std::string& name);
static std::vector<std::string> ConfigureGpuMode(
const std::string& vmm_name, const std::string& gpu_mode);
@@ -67,8 +67,8 @@
const std::pair<int,int>& version,
int major, int minor);
- const vsoc::CuttlefishConfig* config_;
- VmManager(const vsoc::CuttlefishConfig* config);
+ const cuttlefish::CuttlefishConfig* config_;
+ VmManager(const cuttlefish::CuttlefishConfig* config);
bool frontend_enabled_;
std::string kernel_cmdline_;
@@ -76,7 +76,7 @@
private:
struct VmManagerHelper {
// The singleton implementation
- std::function<VmManager*(const vsoc::CuttlefishConfig*)> builder;
+ std::function<VmManager*(const cuttlefish::CuttlefishConfig*)> builder;
// Whether the host packages support this vm manager
std::function<bool()> support_checker;
std::function<std::vector<std::string>(const std::string&)> configure_gpu_mode;
