diff options
61 files changed, 1211 insertions, 1287 deletions
diff --git a/binder_service_android.cc b/binder_service_android.cc index 1702ead5..137694a7 100644 --- a/binder_service_android.cc +++ b/binder_service_android.cc @@ -37,8 +37,7 @@ namespace chromeos_update_engine { BinderUpdateEngineAndroidService::BinderUpdateEngineAndroidService( ServiceDelegateAndroidInterface* service_delegate) - : service_delegate_(service_delegate) { -} + : service_delegate_(service_delegate) {} void BinderUpdateEngineAndroidService::SendStatusUpdate( const UpdateEngineStatus& update_engine_status) { diff --git a/binder_service_android.h b/binder_service_android.h index 694b80ae..d8c4e9c3 100644 --- a/binder_service_android.h +++ b/binder_service_android.h @@ -40,9 +40,7 @@ class BinderUpdateEngineAndroidService : public android::os::BnUpdateEngine, ServiceDelegateAndroidInterface* service_delegate); ~BinderUpdateEngineAndroidService() override = default; - const char* ServiceName() const { - return "android.os.UpdateEngineService"; - } + const char* ServiceName() const { return "android.os.UpdateEngineService"; } // ServiceObserverInterface overrides. void SendStatusUpdate( diff --git a/binder_service_brillo.cc b/binder_service_brillo.cc index d082add6..cc747639 100644 --- a/binder_service_brillo.cc +++ b/binder_service_brillo.cc @@ -25,12 +25,12 @@ #include "update_engine/update_status_utils.h" +using android::sp; using android::String16; using android::String8; using android::binder::Status; using android::brillo::IUpdateEngineStatusCallback; using android::brillo::ParcelableUpdateEngineStatus; -using android::sp; using brillo::ErrorPtr; using std::string; using update_engine::UpdateEngineStatus; diff --git a/boot_control_android.cc b/boot_control_android.cc index 421c0912..8909cd90 100644 --- a/boot_control_android.cc +++ b/boot_control_android.cc @@ -232,8 +232,7 @@ bool BootControlAndroid::IsSlotBootable(Slot slot) const { Return<BoolResult> ret = module_->isSlotBootable(slot); if (!ret.isOk()) { LOG(ERROR) << "Unable to determine if slot " << SlotName(slot) - << " is bootable: " - << ret.description(); + << " is bootable: " << ret.description(); return false; } if (ret == BoolResult::INVALID_SLOT) { @@ -248,8 +247,7 @@ bool BootControlAndroid::MarkSlotUnbootable(Slot slot) { auto ret = module_->setSlotAsUnbootable(slot, StoreResultCallback(&result)); if (!ret.isOk()) { LOG(ERROR) << "Unable to call MarkSlotUnbootable for slot " - << SlotName(slot) << ": " - << ret.description(); + << SlotName(slot) << ": " << ret.description(); return false; } if (!result.success) { @@ -279,8 +277,7 @@ bool BootControlAndroid::MarkBootSuccessfulAsync( CommandResult result; auto ret = module_->markBootSuccessful(StoreResultCallback(&result)); if (!ret.isOk()) { - LOG(ERROR) << "Unable to call MarkBootSuccessful: " - << ret.description(); + LOG(ERROR) << "Unable to call MarkBootSuccessful: " << ret.description(); return false; } if (!result.success) { diff --git a/boot_control_chromeos.cc b/boot_control_chromeos.cc index 3dee6604..ccba316c 100644 --- a/boot_control_chromeos.cc +++ b/boot_control_chromeos.cc @@ -124,9 +124,8 @@ bool BootControlChromeOS::Init() { } if (current_slot_ >= num_slots_) { LOG(ERROR) << "Couldn't find the slot number corresponding to the " - "partition " << boot_device - << ", number of slots: " << num_slots_ - << ". This device is not updateable."; + << "partition " << boot_device << ", number of slots: " + << num_slots_ << ". This device is not updateable."; num_slots_ = 1; current_slot_ = BootControlInterface::kInvalidSlot; return false; @@ -303,8 +302,7 @@ bool BootControlChromeOS::IsRemovableDevice(const string& device) { } int BootControlChromeOS::GetPartitionNumber( - const string partition_name, - BootControlInterface::Slot slot) const { + const string partition_name, BootControlInterface::Slot slot) const { if (slot >= num_slots_) { LOG(ERROR) << "Invalid slot number: " << slot << ", we only have " << num_slots_ << " slot(s)"; diff --git a/certificate_checker.cc b/certificate_checker.cc index 6e886e7b..938c66fd 100644 --- a/certificate_checker.cc +++ b/certificate_checker.cc @@ -59,8 +59,7 @@ CertificateChecker* CertificateChecker::cert_checker_singleton_ = nullptr; CertificateChecker::CertificateChecker(PrefsInterface* prefs, OpenSSLWrapper* openssl_wrapper) - : prefs_(prefs), openssl_wrapper_(openssl_wrapper) { -} + : prefs_(prefs), openssl_wrapper_(openssl_wrapper) {} CertificateChecker::~CertificateChecker() { if (cert_checker_singleton_ == this) @@ -128,7 +127,9 @@ int CertificateChecker::VerifySSLCallback(int preverify_ok, ServerToCheck server_to_check) { CHECK(cert_checker_singleton_ != nullptr); return cert_checker_singleton_->CheckCertificateChange( - preverify_ok, x509_ctx, server_to_check) ? 1 : 0; + preverify_ok, x509_ctx, server_to_check) + ? 1 + : 0; } bool CertificateChecker::CheckCertificateChange(int preverify_ok, @@ -147,10 +148,8 @@ bool CertificateChecker::CheckCertificateChange(int preverify_ok, unsigned int digest_length; uint8_t digest[EVP_MAX_MD_SIZE]; - if (!openssl_wrapper_->GetCertificateDigest(x509_ctx, - &depth, - &digest_length, - digest)) { + if (!openssl_wrapper_->GetCertificateDigest( + x509_ctx, &depth, &digest_length, digest)) { LOG(WARNING) << "Failed to generate digest of X509 certificate " << "from update server."; NotifyCertificateChecked(server_to_check, CertificateCheckResult::kValid); @@ -161,9 +160,10 @@ bool CertificateChecker::CheckCertificateChange(int preverify_ok, // prefs. string digest_string = base::HexEncode(digest, digest_length); - string storage_key = - base::StringPrintf("%s-%d-%d", kPrefsUpdateServerCertificate, - static_cast<int>(server_to_check), depth); + string storage_key = base::StringPrintf("%s-%d-%d", + kPrefsUpdateServerCertificate, + static_cast<int>(server_to_check), + depth); string stored_digest; // If there's no stored certificate, we just store the current one and return. if (!prefs_->GetString(storage_key, &stored_digest)) { @@ -195,8 +195,7 @@ bool CertificateChecker::CheckCertificateChange(int preverify_ok, } void CertificateChecker::NotifyCertificateChecked( - ServerToCheck server_to_check, - CertificateCheckResult result) { + ServerToCheck server_to_check, CertificateCheckResult result) { if (observer_) observer_->CertificateChecked(server_to_check, result); } diff --git a/certificate_checker_unittest.cc b/certificate_checker_unittest.cc index 66b92d68..15d65552 100644 --- a/certificate_checker_unittest.cc +++ b/certificate_checker_unittest.cc @@ -27,12 +27,12 @@ #include "update_engine/common/mock_prefs.h" #include "update_engine/mock_certificate_checker.h" +using std::string; +using ::testing::_; using ::testing::DoAll; using ::testing::Return; using ::testing::SetArgPointee; using ::testing::SetArrayArgument; -using ::testing::_; -using std::string; namespace chromeos_update_engine { @@ -54,9 +54,7 @@ class CertificateCheckerTest : public testing::Test { cert_checker.SetObserver(&observer_); } - void TearDown() override { - cert_checker.SetObserver(nullptr); - } + void TearDown() override { cert_checker.SetObserver(nullptr); } MockPrefs prefs_; MockOpenSSLWrapper openssl_wrapper_; @@ -77,16 +75,15 @@ class CertificateCheckerTest : public testing::Test { // check certificate change, new TEST_F(CertificateCheckerTest, NewCertificate) { EXPECT_CALL(openssl_wrapper_, GetCertificateDigest(nullptr, _, _, _)) - .WillOnce(DoAll( - SetArgPointee<1>(depth_), - SetArgPointee<2>(length_), - SetArrayArgument<3>(digest_, digest_ + 4), - Return(true))); + .WillOnce(DoAll(SetArgPointee<1>(depth_), + SetArgPointee<2>(length_), + SetArrayArgument<3>(digest_, digest_ + 4), + Return(true))); EXPECT_CALL(prefs_, GetString(cert_key_, _)).WillOnce(Return(false)); EXPECT_CALL(prefs_, SetString(cert_key_, digest_hex_)).WillOnce(Return(true)); - EXPECT_CALL(observer_, - CertificateChecked(server_to_check_, - CertificateCheckResult::kValid)); + EXPECT_CALL( + observer_, + CertificateChecked(server_to_check_, CertificateCheckResult::kValid)); ASSERT_TRUE( cert_checker.CheckCertificateChange(1, nullptr, server_to_check_)); } @@ -94,17 +91,16 @@ TEST_F(CertificateCheckerTest, NewCertificate) { // check certificate change, unchanged TEST_F(CertificateCheckerTest, SameCertificate) { EXPECT_CALL(openssl_wrapper_, GetCertificateDigest(nullptr, _, _, _)) - .WillOnce(DoAll( - SetArgPointee<1>(depth_), - SetArgPointee<2>(length_), - SetArrayArgument<3>(digest_, digest_ + 4), - Return(true))); + .WillOnce(DoAll(SetArgPointee<1>(depth_), + SetArgPointee<2>(length_), + SetArrayArgument<3>(digest_, digest_ + 4), + Return(true))); EXPECT_CALL(prefs_, GetString(cert_key_, _)) .WillOnce(DoAll(SetArgPointee<1>(digest_hex_), Return(true))); EXPECT_CALL(prefs_, SetString(_, _)).Times(0); - EXPECT_CALL(observer_, - CertificateChecked(server_to_check_, - CertificateCheckResult::kValid)); + EXPECT_CALL( + observer_, + CertificateChecked(server_to_check_, CertificateCheckResult::kValid)); ASSERT_TRUE( cert_checker.CheckCertificateChange(1, nullptr, server_to_check_)); } @@ -112,11 +108,10 @@ TEST_F(CertificateCheckerTest, SameCertificate) { // check certificate change, changed TEST_F(CertificateCheckerTest, ChangedCertificate) { EXPECT_CALL(openssl_wrapper_, GetCertificateDigest(nullptr, _, _, _)) - .WillOnce(DoAll( - SetArgPointee<1>(depth_), - SetArgPointee<2>(length_), - SetArrayArgument<3>(digest_, digest_ + 4), - Return(true))); + .WillOnce(DoAll(SetArgPointee<1>(depth_), + SetArgPointee<2>(length_), + SetArrayArgument<3>(digest_, digest_ + 4), + Return(true))); EXPECT_CALL(prefs_, GetString(cert_key_, _)) .WillOnce(DoAll(SetArgPointee<1>(diff_digest_hex_), Return(true))); EXPECT_CALL(observer_, @@ -129,8 +124,9 @@ TEST_F(CertificateCheckerTest, ChangedCertificate) { // check certificate change, failed TEST_F(CertificateCheckerTest, FailedCertificate) { - EXPECT_CALL(observer_, CertificateChecked(server_to_check_, - CertificateCheckResult::kFailed)); + EXPECT_CALL( + observer_, + CertificateChecked(server_to_check_, CertificateCheckResult::kFailed)); EXPECT_CALL(prefs_, GetString(_, _)).Times(0); EXPECT_CALL(openssl_wrapper_, GetCertificateDigest(_, _, _, _)).Times(0); ASSERT_FALSE( diff --git a/chrome_browser_proxy_resolver.cc b/chrome_browser_proxy_resolver.cc index 5beecc1f..bfb58f7b 100644 --- a/chrome_browser_proxy_resolver.cc +++ b/chrome_browser_proxy_resolver.cc @@ -28,8 +28,7 @@ namespace chromeos_update_engine { ChromeBrowserProxyResolver::ChromeBrowserProxyResolver() - : next_request_id_(kProxyRequestIdNull + 1), - weak_ptr_factory_(this) {} + : next_request_id_(kProxyRequestIdNull + 1), weak_ptr_factory_(this) {} ChromeBrowserProxyResolver::~ChromeBrowserProxyResolver() = default; @@ -37,9 +36,11 @@ ProxyRequestId ChromeBrowserProxyResolver::GetProxiesForUrl( const std::string& url, const ProxiesResolvedFn& callback) { const ProxyRequestId id = next_request_id_++; brillo::http::GetChromeProxyServersAsync( - DBusConnection::Get()->GetDBus(), url, + DBusConnection::Get()->GetDBus(), + url, base::Bind(&ChromeBrowserProxyResolver::OnGetChromeProxyServers, - weak_ptr_factory_.GetWeakPtr(), id)); + weak_ptr_factory_.GetWeakPtr(), + id)); pending_callbacks_[id] = callback; return id; } @@ -49,7 +50,8 @@ bool ChromeBrowserProxyResolver::CancelProxyRequest(ProxyRequestId request) { } void ChromeBrowserProxyResolver::OnGetChromeProxyServers( - ProxyRequestId request_id, bool success, + ProxyRequestId request_id, + bool success, const std::vector<std::string>& proxies) { // If |success| is false, |proxies| will still hold the direct proxy option // which is what we do in our error case. diff --git a/common_service.cc b/common_service.cc index 88ead28c..0d5ee6dc 100644 --- a/common_service.cc +++ b/common_service.cc @@ -71,8 +71,7 @@ const char* const UpdateEngineService::kErrorFailed = "org.chromium.UpdateEngine.Error.Failed"; UpdateEngineService::UpdateEngineService(SystemState* system_state) - : system_state_(system_state) { -} + : system_state_(system_state) {} // org::chromium::UpdateEngineInterfaceInterface methods implementation. diff --git a/common_service_unittest.cc b/common_service_unittest.cc index edf90b09..65202a06 100644 --- a/common_service_unittest.cc +++ b/common_service_unittest.cc @@ -43,9 +43,7 @@ class UpdateEngineServiceTest : public ::testing::Test { : mock_update_attempter_(fake_system_state_.mock_update_attempter()), common_service_(&fake_system_state_) {} - void SetUp() override { - fake_system_state_.set_device_policy(nullptr); - } + void SetUp() override { fake_system_state_.set_device_policy(nullptr); } // Fake/mock infrastructure. FakeSystemState fake_system_state_; @@ -133,7 +131,8 @@ TEST_F(UpdateEngineServiceTest, SetChannelWithDelegatedPolicy) { TEST_F(UpdateEngineServiceTest, SetChannelWithInvalidChannel) { EXPECT_CALL(*mock_update_attempter_, RefreshDevicePolicy()); EXPECT_CALL(*fake_system_state_.mock_request_params(), - SetTargetChannel("foo-channel", true, _)).WillOnce(Return(false)); + SetTargetChannel("foo-channel", true, _)) + .WillOnce(Return(false)); EXPECT_FALSE(common_service_.SetChannel(&error_, "foo-channel", true)); ASSERT_NE(nullptr, error_); diff --git a/connection_manager.cc b/connection_manager.cc index a048f5f4..7263a742 100644 --- a/connection_manager.cc +++ b/connection_manager.cc @@ -46,7 +46,7 @@ std::unique_ptr<ConnectionManagerInterface> CreateConnectionManager( return std::unique_ptr<ConnectionManagerInterface>( new ConnectionManager(new ShillProxy(), system_state)); } -} +} // namespace connection_manager ConnectionManager::ConnectionManager(ShillProxyInterface* shill_proxy, SystemState* system_state) diff --git a/connection_manager_android.cc b/connection_manager_android.cc index 6da4cee0..9d0c57bb 100644 --- a/connection_manager_android.cc +++ b/connection_manager_android.cc @@ -26,7 +26,7 @@ std::unique_ptr<ConnectionManagerInterface> CreateConnectionManager( return std::unique_ptr<ConnectionManagerInterface>( new ConnectionManagerAndroid()); } -} +} // namespace connection_manager bool ConnectionManagerAndroid::GetConnectionProperties( ConnectionType* out_type, ConnectionTethering* out_tethering) { diff --git a/connection_manager_interface.h b/connection_manager_interface.h index 2faeb804..9f779891 100644 --- a/connection_manager_interface.h +++ b/connection_manager_interface.h @@ -61,7 +61,7 @@ namespace connection_manager { // Factory function which creates a ConnectionManager. std::unique_ptr<ConnectionManagerInterface> CreateConnectionManager( SystemState* system_state); -} +} // namespace connection_manager } // namespace chromeos_update_engine diff --git a/connection_manager_unittest.cc b/connection_manager_unittest.cc index 7cd858d4..3cdaf4cd 100644 --- a/connection_manager_unittest.cc +++ b/connection_manager_unittest.cc @@ -40,9 +40,9 @@ using org::chromium::flimflam::ManagerProxyMock; using org::chromium::flimflam::ServiceProxyMock; using std::set; using std::string; +using testing::_; using testing::Return; using testing::SetArgPointee; -using testing::_; namespace chromeos_update_engine { @@ -71,16 +71,14 @@ class ConnectionManagerTest : public ::testing::Test { const char* physical_technology, const char* service_tethering); - void TestWithServiceType( - const char* service_type, - const char* physical_technology, - ConnectionType expected_type); + void TestWithServiceType(const char* service_type, + const char* physical_technology, + ConnectionType expected_type); void TestWithServiceDisconnected(ConnectionType expected_type); - void TestWithServiceTethering( - const char* service_tethering, - ConnectionTethering expected_tethering); + void TestWithServiceTethering(const char* service_tethering, + ConnectionTethering expected_tethering); brillo::FakeMessageLoop loop_{nullptr}; FakeSystemState fake_system_state_; @@ -140,10 +138,9 @@ void ConnectionManagerTest::SetServiceReply(const string& service_path, std::move(service_proxy_mock)); } -void ConnectionManagerTest::TestWithServiceType( - const char* service_type, - const char* physical_technology, - ConnectionType expected_type) { +void ConnectionManagerTest::TestWithServiceType(const char* service_type, + const char* physical_technology, + ConnectionType expected_type) { SetManagerReply("/service/guest/network", true); SetServiceReply("/service/guest/network", service_type, @@ -159,8 +156,7 @@ void ConnectionManagerTest::TestWithServiceType( } void ConnectionManagerTest::TestWithServiceTethering( - const char* service_tethering, - ConnectionTethering expected_tethering) { + const char* service_tethering, ConnectionTethering expected_tethering) { SetManagerReply("/service/guest/network", true); SetServiceReply( "/service/guest/network", shill::kTypeWifi, nullptr, service_tethering); @@ -66,7 +66,7 @@ int UpdateEngineDaemon::OnInit() { // Create the Binder Service. #if USE_OMAHA binder_service_ = new BinderUpdateEngineBrilloService{real_system_state}; -#else // !USE_OMAHA +#else // !USE_OMAHA binder_service_ = new BinderUpdateEngineAndroidService{ daemon_state_android->service_delegate()}; #endif // USE_OMAHA @@ -87,7 +87,7 @@ int UpdateEngineDaemon::OnInit() { dbus_adaptor_->RegisterAsync(base::Bind(&UpdateEngineDaemon::OnDBusRegistered, base::Unretained(this))); LOG(INFO) << "Waiting for DBus object to be registered."; -#else // !USE_DBUS +#else // !USE_DBUS daemon_state_->StartUpdater(); #endif // USE_DBUS return EX_OK; diff --git a/dbus_service.cc b/dbus_service.cc index 03425b6d..72960532 100644 --- a/dbus_service.cc +++ b/dbus_service.cc @@ -34,8 +34,7 @@ using std::vector; using update_engine::UpdateEngineStatus; DBusUpdateEngineService::DBusUpdateEngineService(SystemState* system_state) - : common_(new UpdateEngineService{system_state}) { -} + : common_(new UpdateEngineService{system_state}) {} // org::chromium::UpdateEngineInterfaceInterface methods implementation. diff --git a/fake_file_writer.h b/fake_file_writer.h index 43b71c7e..75507ea5 100644 --- a/fake_file_writer.h +++ b/fake_file_writer.h @@ -56,9 +56,7 @@ class FakeFileWriter : public FileWriter { return 0; } - const brillo::Blob& bytes() { - return bytes_; - } + const brillo::Blob& bytes() { return bytes_; } private: // The internal store of all bytes that have been written diff --git a/fake_p2p_manager.h b/fake_p2p_manager.h index a8cf4ea6..1f8ae95f 100644 --- a/fake_p2p_manager.h +++ b/fake_p2p_manager.h @@ -26,31 +26,23 @@ namespace chromeos_update_engine { // A fake implementation of P2PManager. class FakeP2PManager : public P2PManager { public: - FakeP2PManager() : - is_p2p_enabled_(false), - ensure_p2p_running_result_(false), - ensure_p2p_not_running_result_(false), - perform_housekeeping_result_(false), - count_shared_files_result_(0) {} + FakeP2PManager() + : is_p2p_enabled_(false), + ensure_p2p_running_result_(false), + ensure_p2p_not_running_result_(false), + perform_housekeeping_result_(false), + count_shared_files_result_(0) {} // P2PManager overrides. void SetDevicePolicy(const policy::DevicePolicy* device_policy) override {} - bool IsP2PEnabled() override { - return is_p2p_enabled_; - } + bool IsP2PEnabled() override { return is_p2p_enabled_; } - bool EnsureP2PRunning() override { - return ensure_p2p_running_result_; - } + bool EnsureP2PRunning() override { return ensure_p2p_running_result_; } - bool EnsureP2PNotRunning() override { - return ensure_p2p_not_running_result_; - } + bool EnsureP2PNotRunning() override { return ensure_p2p_not_running_result_; } - bool PerformHousekeeping() override { - return perform_housekeeping_result_; - } + bool PerformHousekeeping() override { return perform_housekeeping_result_; } void LookupUrlForFile(const std::string& file_id, size_t minimum_size, @@ -59,8 +51,7 @@ class FakeP2PManager : public P2PManager { callback.Run(lookup_url_for_file_result_); } - bool FileShare(const std::string& file_id, - size_t expected_size) override { + bool FileShare(const std::string& file_id, size_t expected_size) override { return false; } @@ -68,31 +59,22 @@ class FakeP2PManager : public P2PManager { return base::FilePath(); } - ssize_t FileGetSize(const std::string& file_id) override { - return -1; - } + ssize_t FileGetSize(const std::string& file_id) override { return -1; } ssize_t FileGetExpectedSize(const std::string& file_id) override { return -1; } - bool FileGetVisible(const std::string& file_id, - bool *out_result) override { + bool FileGetVisible(const std::string& file_id, bool* out_result) override { return false; } - bool FileMakeVisible(const std::string& file_id) override { - return false; - } + bool FileMakeVisible(const std::string& file_id) override { return false; } - int CountSharedFiles() override { - return count_shared_files_result_; - } + int CountSharedFiles() override { return count_shared_files_result_; } // Methods for controlling what the fake returns and how it acts. - void SetP2PEnabled(bool is_p2p_enabled) { - is_p2p_enabled_ = is_p2p_enabled; - } + void SetP2PEnabled(bool is_p2p_enabled) { is_p2p_enabled_ = is_p2p_enabled; } void SetEnsureP2PRunningResult(bool ensure_p2p_running_result) { ensure_p2p_running_result_ = ensure_p2p_running_result; diff --git a/fake_p2p_manager_configuration.h b/fake_p2p_manager_configuration.h index c1cf4f2d..f5b0e80d 100644 --- a/fake_p2p_manager_configuration.h +++ b/fake_p2p_manager_configuration.h @@ -32,9 +32,7 @@ namespace chromeos_update_engine { // /var/cache/p2p, a temporary directory is used. class FakeP2PManagerConfiguration : public P2PManager::Configuration { public: - FakeP2PManagerConfiguration() { - EXPECT_TRUE(p2p_dir_.CreateUniqueTempDir()); - } + FakeP2PManagerConfiguration() { EXPECT_TRUE(p2p_dir_.CreateUniqueTempDir()); } // P2PManager::Configuration override base::FilePath GetP2PDir() override { return p2p_dir_.GetPath(); } @@ -45,15 +43,15 @@ class FakeP2PManagerConfiguration : public P2PManager::Configuration { } // P2PManager::Configuration override - std::vector<std::string> GetP2PClientArgs(const std::string &file_id, + std::vector<std::string> GetP2PClientArgs(const std::string& file_id, size_t minimum_size) override { std::vector<std::string> formatted_command = p2p_client_cmd_format_; // Replace {variable} on the passed string. std::string str_minimum_size = std::to_string(minimum_size); for (std::string& arg : formatted_command) { base::ReplaceSubstringsAfterOffset(&arg, 0, "{file_id}", file_id); - base::ReplaceSubstringsAfterOffset(&arg, 0, "{minsize}", - str_minimum_size); + base::ReplaceSubstringsAfterOffset( + &arg, 0, "{minsize}", str_minimum_size); } return formatted_command; } diff --git a/fake_shill_proxy.cc b/fake_shill_proxy.cc index 17698cd1..de965119 100644 --- a/fake_shill_proxy.cc +++ b/fake_shill_proxy.cc @@ -16,6 +16,8 @@ #include "update_engine/fake_shill_proxy.h" +#include <utility> + using org::chromium::flimflam::ManagerProxyMock; using org::chromium::flimflam::ServiceProxyInterface; @@ -31,8 +33,8 @@ ManagerProxyMock* FakeShillProxy::GetManagerProxy() { std::unique_ptr<ServiceProxyInterface> FakeShillProxy::GetServiceForPath( const dbus::ObjectPath& path) { auto it = service_proxy_mocks_.find(path.value()); - CHECK(it != service_proxy_mocks_.end()) << "No ServiceProxyMock set for " - << path.value(); + CHECK(it != service_proxy_mocks_.end()) + << "No ServiceProxyMock set for " << path.value(); std::unique_ptr<ServiceProxyInterface> result = std::move(it->second); service_proxy_mocks_.erase(it); return result; diff --git a/fake_system_state.h b/fake_system_state.h index 627bd5cd..24b1eec2 100644 --- a/fake_system_state.h +++ b/fake_system_state.h @@ -118,8 +118,8 @@ class FakeSystemState : public SystemState { inline void set_connection_manager( ConnectionManagerInterface* connection_manager) { - connection_manager_ = (connection_manager ? connection_manager : - &mock_connection_manager_); + connection_manager_ = + (connection_manager ? connection_manager : &mock_connection_manager_); } inline void set_hardware(HardwareInterface* hardware) { @@ -136,30 +136,30 @@ class FakeSystemState : public SystemState { } inline void set_powerwash_safe_prefs(PrefsInterface* powerwash_safe_prefs) { - powerwash_safe_prefs_ = (powerwash_safe_prefs ? powerwash_safe_prefs : - &mock_powerwash_safe_prefs_); + powerwash_safe_prefs_ = + (powerwash_safe_prefs ? powerwash_safe_prefs + : &mock_powerwash_safe_prefs_); } - inline void set_payload_state(PayloadStateInterface *payload_state) { + inline void set_payload_state(PayloadStateInterface* payload_state) { payload_state_ = payload_state ? payload_state : &mock_payload_state_; } inline void set_update_attempter(UpdateAttempter* update_attempter) { - update_attempter_ = (update_attempter ? update_attempter : - &mock_update_attempter_); + update_attempter_ = + (update_attempter ? update_attempter : &mock_update_attempter_); } inline void set_request_params(OmahaRequestParams* request_params) { - request_params_ = (request_params ? request_params : - &mock_request_params_); + request_params_ = (request_params ? request_params : &mock_request_params_); } - inline void set_p2p_manager(P2PManager *p2p_manager) { + inline void set_p2p_manager(P2PManager* p2p_manager) { p2p_manager_ = p2p_manager ? p2p_manager : &mock_p2p_manager_; } inline void set_update_manager( - chromeos_update_manager::UpdateManager *update_manager) { + chromeos_update_manager::UpdateManager* update_manager) { update_manager_ = update_manager ? update_manager : &fake_update_manager_; } @@ -201,12 +201,12 @@ class FakeSystemState : public SystemState { return &mock_metrics_reporter_; } - inline testing::NiceMock<MockPrefs> *mock_prefs() { + inline testing::NiceMock<MockPrefs>* mock_prefs() { CHECK(prefs_ == &mock_prefs_); return &mock_prefs_; } - inline testing::NiceMock<MockPrefs> *mock_powerwash_safe_prefs() { + inline testing::NiceMock<MockPrefs>* mock_powerwash_safe_prefs() { CHECK(powerwash_safe_prefs_ == &mock_powerwash_safe_prefs_); return &mock_powerwash_safe_prefs_; } diff --git a/hardware_chromeos.cc b/hardware_chromeos.cc index 39493284..c5933b54 100644 --- a/hardware_chromeos.cc +++ b/hardware_chromeos.cc @@ -131,8 +131,7 @@ bool HardwareChromeOS::IsOOBEComplete(base::Time* out_time_of_oobe) const { struct stat statbuf; if (stat(kOOBECompletedMarker, &statbuf) != 0) { if (errno != ENOENT) { - PLOG(ERROR) << "Error getting information about " - << kOOBECompletedMarker; + PLOG(ERROR) << "Error getting information about " << kOOBECompletedMarker; } return false; } @@ -145,8 +144,8 @@ bool HardwareChromeOS::IsOOBEComplete(base::Time* out_time_of_oobe) const { static string ReadValueFromCrosSystem(const string& key) { char value_buffer[VB_MAX_STRING_PROPERTY]; - const char* rv = VbGetSystemPropertyString(key.c_str(), value_buffer, - sizeof(value_buffer)); + const char* rv = VbGetSystemPropertyString( + key.c_str(), value_buffer, sizeof(value_buffer)); if (rv != nullptr) { string return_value(value_buffer); base::TrimWhitespaceASCII(return_value, base::TRIM_ALL, &return_value); @@ -212,8 +211,8 @@ bool HardwareChromeOS::SetMaxKernelKeyRollforward(int kernel_max_rollforward) { int HardwareChromeOS::GetPowerwashCount() const { int powerwash_count; - base::FilePath marker_path = base::FilePath(kPowerwashSafeDirectory).Append( - kPowerwashCountMarker); + base::FilePath marker_path = + base::FilePath(kPowerwashSafeDirectory).Append(kPowerwashCountMarker); string contents; if (!utils::ReadFile(marker_path.value(), &contents)) return -1; @@ -287,7 +286,7 @@ void HardwareChromeOS::LoadConfig(const string& root_prefix, bool normal_mode) { bool HardwareChromeOS::GetFirstActiveOmahaPingSent() const { int exit_code = 0; string active_ping_str; - vector<string> cmd = { "vpd_get_value", kActivePingKey }; + vector<string> cmd = {"vpd_get_value", kActivePingKey}; if (!Subprocess::SynchronousExec(cmd, &exit_code, &active_ping_str) || exit_code) { LOG(ERROR) << "Failed to get vpd key for " << kActivePingKey @@ -295,9 +294,7 @@ bool HardwareChromeOS::GetFirstActiveOmahaPingSent() const { return false; } - base::TrimWhitespaceASCII(active_ping_str, - base::TRIM_ALL, - &active_ping_str); + base::TrimWhitespaceASCII(active_ping_str, base::TRIM_ALL, &active_ping_str); int active_ping; if (active_ping_str.empty() || !base::StringToInt(active_ping_str, &active_ping)) { @@ -311,21 +308,19 @@ bool HardwareChromeOS::SetFirstActiveOmahaPingSent() { int exit_code = 0; string output; vector<string> vpd_set_cmd = { - "vpd", "-i", "RW_VPD", "-s", string(kActivePingKey) + "=1" }; + "vpd", "-i", "RW_VPD", "-s", string(kActivePingKey) + "=1"}; if (!Subprocess::SynchronousExec(vpd_set_cmd, &exit_code, &output) || exit_code) { LOG(ERROR) << "Failed to set vpd key for " << kActivePingKey - << " with exit code: " << exit_code - << " with error: " << output; + << " with exit code: " << exit_code << " with error: " << output; return false; } - vector<string> vpd_dump_cmd = { "dump_vpd_log", "--force" }; + vector<string> vpd_dump_cmd = {"dump_vpd_log", "--force"}; if (!Subprocess::SynchronousExec(vpd_dump_cmd, &exit_code, &output) || exit_code) { - LOG(ERROR) << "Failed to cache " << kActivePingKey<< " using dump_vpd_log" - << " with exit code: " << exit_code - << " with error: " << output; + LOG(ERROR) << "Failed to cache " << kActivePingKey << " using dump_vpd_log" + << " with exit code: " << exit_code << " with error: " << output; return false; } return true; diff --git a/image_properties_chromeos.cc b/image_properties_chromeos.cc index 87c32f01..5ab8f052 100644 --- a/image_properties_chromeos.cc +++ b/image_properties_chromeos.cc @@ -114,7 +114,8 @@ ImageProperties LoadImageProperties(SystemState* system_state) { result.board = GetStringWithDefault(lsb_release, kLsbReleaseBoardKey, ""); result.version = GetStringWithDefault(lsb_release, kLsbReleaseVersionKey, ""); result.omaha_url = - GetStringWithDefault(lsb_release, kLsbReleaseAutoUpdateServerKey, + GetStringWithDefault(lsb_release, + kLsbReleaseAutoUpdateServerKey, constants::kOmahaDefaultProductionURL); // Build fingerprint not used in Chrome OS. result.build_fingerprint = ""; diff --git a/libcurl_http_fetcher.cc b/libcurl_http_fetcher.cc index 7cf3341c..ce3475d4 100644 --- a/libcurl_http_fetcher.cc +++ b/libcurl_http_fetcher.cc @@ -164,29 +164,26 @@ void LibcurlHttpFetcher::ResumeTransfer(const string& url) { bool is_direct = (GetCurrentProxy() == kNoProxy); LOG(INFO) << "Using proxy: " << (is_direct ? "no" : "yes"); if (is_direct) { - CHECK_EQ(curl_easy_setopt(curl_handle_, - CURLOPT_PROXY, - ""), CURLE_OK); + CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_PROXY, ""), CURLE_OK); } else { - CHECK_EQ(curl_easy_setopt(curl_handle_, - CURLOPT_PROXY, - GetCurrentProxy().c_str()), CURLE_OK); + CHECK_EQ(curl_easy_setopt( + curl_handle_, CURLOPT_PROXY, GetCurrentProxy().c_str()), + CURLE_OK); // Curl seems to require us to set the protocol curl_proxytype type; if (GetProxyType(GetCurrentProxy(), &type)) { - CHECK_EQ(curl_easy_setopt(curl_handle_, - CURLOPT_PROXYTYPE, - type), CURLE_OK); + CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_PROXYTYPE, type), + CURLE_OK); } } if (post_data_set_) { CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_POST, 1), CURLE_OK); - CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_POSTFIELDS, - post_data_.data()), - CURLE_OK); - CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_POSTFIELDSIZE, - post_data_.size()), + CHECK_EQ( + curl_easy_setopt(curl_handle_, CURLOPT_POSTFIELDS, post_data_.data()), + CURLE_OK); + CHECK_EQ(curl_easy_setopt( + curl_handle_, CURLOPT_POSTFIELDSIZE, post_data_.size()), CURLE_OK); } @@ -225,7 +222,7 @@ void LibcurlHttpFetcher::ResumeTransfer(const string& url) { size_t end_offset = 0; if (download_length_) { end_offset = static_cast<size_t>(resume_offset_) + download_length_ - 1; - CHECK_LE((size_t) resume_offset_, end_offset); + CHECK_LE((size_t)resume_offset_, end_offset); } // Create a string representation of the desired range. @@ -238,30 +235,30 @@ void LibcurlHttpFetcher::ResumeTransfer(const string& url) { } CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_WRITEDATA, this), CURLE_OK); - CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_WRITEFUNCTION, - StaticLibcurlWrite), CURLE_OK); - CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_URL, url_.c_str()), - CURLE_OK); + CHECK_EQ( + curl_easy_setopt(curl_handle_, CURLOPT_WRITEFUNCTION, StaticLibcurlWrite), + CURLE_OK); + CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_URL, url_.c_str()), CURLE_OK); // If the connection drops under |low_speed_limit_bps_| (10 // bytes/sec by default) for |low_speed_time_seconds_| (90 seconds, // 180 on non-official builds), reconnect. - CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_LOW_SPEED_LIMIT, - low_speed_limit_bps_), + CHECK_EQ(curl_easy_setopt( + curl_handle_, CURLOPT_LOW_SPEED_LIMIT, low_speed_limit_bps_), CURLE_OK); - CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_LOW_SPEED_TIME, - low_speed_time_seconds_), + CHECK_EQ(curl_easy_setopt( + curl_handle_, CURLOPT_LOW_SPEED_TIME, low_speed_time_seconds_), CURLE_OK); - CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_CONNECTTIMEOUT, - connect_timeout_seconds_), + CHECK_EQ(curl_easy_setopt( + curl_handle_, CURLOPT_CONNECTTIMEOUT, connect_timeout_seconds_), CURLE_OK); // By default, libcurl doesn't follow redirections. Allow up to // |kDownloadMaxRedirects| redirections. CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_FOLLOWLOCATION, 1), CURLE_OK); - CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_MAXREDIRS, - kDownloadMaxRedirects), - CURLE_OK); + CHECK_EQ( + curl_easy_setopt(curl_handle_, CURLOPT_MAXREDIRS, kDownloadMaxRedirects), + CURLE_OK); // Lock down the appropriate curl options for HTTP or HTTPS depending on // the url. @@ -296,9 +293,9 @@ void LibcurlHttpFetcher::SetCurlOptionsForHttp() { LOG(INFO) << "Setting up curl options for HTTP"; CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_PROTOCOLS, CURLPROTO_HTTP), CURLE_OK); - CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_REDIR_PROTOCOLS, - CURLPROTO_HTTP), - CURLE_OK); + CHECK_EQ( + curl_easy_setopt(curl_handle_, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP), + CURLE_OK); } // Security lock-down in official builds: makes sure that peer certificate @@ -306,25 +303,24 @@ void LibcurlHttpFetcher::SetCurlOptionsForHttp() { // restricts protocols to HTTPS, restricts ciphers to HIGH. void LibcurlHttpFetcher::SetCurlOptionsForHttps() { LOG(INFO) << "Setting up curl options for HTTPS"; - CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_SSL_VERIFYPEER, 1), - CURLE_OK); - CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_SSL_VERIFYHOST, 2), - CURLE_OK); - CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_CAPATH, - constants::kCACertificatesPath), + CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_SSL_VERIFYPEER, 1), CURLE_OK); + CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_SSL_VERIFYHOST, 2), CURLE_OK); + CHECK_EQ(curl_easy_setopt( + curl_handle_, CURLOPT_CAPATH, constants::kCACertificatesPath), CURLE_OK); CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_PROTOCOLS, CURLPROTO_HTTPS), CURLE_OK); - CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_REDIR_PROTOCOLS, - CURLPROTO_HTTPS), - CURLE_OK); + CHECK_EQ( + curl_easy_setopt(curl_handle_, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTPS), + CURLE_OK); CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_SSL_CIPHER_LIST, "HIGH:!ADH"), CURLE_OK); if (server_to_check_ != ServerToCheck::kNone) { CHECK_EQ( curl_easy_setopt(curl_handle_, CURLOPT_SSL_CTX_DATA, &server_to_check_), CURLE_OK); - CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_SSL_CTX_FUNCTION, + CHECK_EQ(curl_easy_setopt(curl_handle_, + CURLOPT_SSL_CTX_FUNCTION, CertificateChecker::ProcessSSLContext), CURLE_OK); } @@ -344,8 +340,8 @@ void LibcurlHttpFetcher::SetCurlOptionsForFile() { void LibcurlHttpFetcher::BeginTransfer(const string& url) { CHECK(!transfer_in_progress_); url_ = url; - auto closure = base::Bind(&LibcurlHttpFetcher::ProxiesResolved, - base::Unretained(this)); + auto closure = + base::Bind(&LibcurlHttpFetcher::ProxiesResolved, base::Unretained(this)); ResolveProxiesForUrl(url_, closure); } @@ -443,8 +439,7 @@ void LibcurlHttpFetcher::CurlPerformOnce() { // update engine performs an update check while the network is not ready // (e.g., right after resume). Longer term, we should check if the network // is online/offline and return an appropriate error code. - if (!sent_byte_ && - http_response_code_ == 0 && + if (!sent_byte_ && http_response_code_ == 0 && no_network_retry_count_ < no_network_max_retries_) { no_network_retry_count_++; retry_task_id_ = MessageLoop::current()->PostDelayedTask( @@ -487,8 +482,8 @@ void LibcurlHttpFetcher::CurlPerformOnce() { } else if ((transfer_size_ >= 0) && (bytes_downloaded_ < transfer_size_)) { if (!ignore_failure_) retry_count_++; - LOG(INFO) << "Transfer interrupted after downloading " - << bytes_downloaded_ << " of " << transfer_size_ << " bytes. " + LOG(INFO) << "Transfer interrupted after downloading " << bytes_downloaded_ + << " of " << transfer_size_ << " bytes. " << transfer_size_ - bytes_downloaded_ << " bytes remaining " << "after " << retry_count_ << " attempt(s)"; @@ -506,8 +501,8 @@ void LibcurlHttpFetcher::CurlPerformOnce() { base::Unretained(this)), TimeDelta::FromSeconds(retry_seconds_)); } else { - LOG(INFO) << "Transfer completed (" << http_response_code_ - << "), " << bytes_downloaded_ << " bytes downloaded"; + LOG(INFO) << "Transfer completed (" << http_response_code_ << "), " + << bytes_downloaded_ << " bytes downloaded"; if (delegate_) { bool success = IsHttpResponseSuccess(); delegate_->TransferComplete(this, success); @@ -520,7 +515,7 @@ void LibcurlHttpFetcher::CurlPerformOnce() { ignore_failure_ = false; } -size_t LibcurlHttpFetcher::LibcurlWrite(void *ptr, size_t size, size_t nmemb) { +size_t LibcurlHttpFetcher::LibcurlWrite(void* ptr, size_t size, size_t nmemb) { // Update HTTP response first. GetHttpResponseCode(); const size_t payload_size = size * nmemb; @@ -537,7 +532,8 @@ size_t LibcurlHttpFetcher::LibcurlWrite(void *ptr, size_t size, size_t nmemb) { double transfer_size_double; CHECK_EQ(curl_easy_getinfo(curl_handle_, CURLINFO_CONTENT_LENGTH_DOWNLOAD, - &transfer_size_double), CURLE_OK); + &transfer_size_double), + CURLE_OK); off_t new_transfer_size = static_cast<off_t>(transfer_size_double); if (new_transfer_size > 0) { transfer_size_ = resume_offset_ + new_transfer_size; @@ -613,8 +609,9 @@ void LibcurlHttpFetcher::SetupMessageLoopSources() { // Ask libcurl for the set of file descriptors we should track on its // behalf. - CHECK_EQ(curl_multi_fdset(curl_multi_handle_, &fd_read, &fd_write, - &fd_exc, &fd_max), CURLM_OK); + CHECK_EQ(curl_multi_fdset( + curl_multi_handle_, &fd_read, &fd_write, &fd_exc, &fd_max), + CURLM_OK); // We should iterate through all file descriptors up to libcurl's fd_max or // the highest one we're tracking, whichever is larger. @@ -632,12 +629,12 @@ void LibcurlHttpFetcher::SetupMessageLoopSources() { // should always be false. bool is_exc = FD_ISSET(fd, &fd_exc) != 0; bool must_track[2] = { - is_exc || (FD_ISSET(fd, &fd_read) != 0), // track 0 -- read - is_exc || (FD_ISSET(fd, &fd_write) != 0) // track 1 -- write + is_exc || (FD_ISSET(fd, &fd_read) != 0), // track 0 -- read + is_exc || (FD_ISSET(fd, &fd_write) != 0) // track 1 -- write }; MessageLoop::WatchMode watch_modes[2] = { - MessageLoop::WatchMode::kWatchRead, - MessageLoop::WatchMode::kWatchWrite, + MessageLoop::WatchMode::kWatchRead, + MessageLoop::WatchMode::kWatchWrite, }; for (size_t t = 0; t < arraysize(fd_task_maps_); ++t) { @@ -720,9 +717,8 @@ void LibcurlHttpFetcher::CleanUp() { for (size_t t = 0; t < arraysize(fd_task_maps_); ++t) { for (const auto& fd_taks_pair : fd_task_maps_[t]) { if (!MessageLoop::current()->CancelTask(fd_taks_pair.second)) { - LOG(WARNING) << "Error canceling the watch task " - << fd_taks_pair.second << " for " - << (t ? "writing" : "reading") << " the fd " + LOG(WARNING) << "Error canceling the watch task " << fd_taks_pair.second + << " for " << (t ? "writing" : "reading") << " the fd " << fd_taks_pair.first; } } diff --git a/libcurl_http_fetcher.h b/libcurl_http_fetcher.h index 61871c95..25a2df3d 100644 --- a/libcurl_http_fetcher.h +++ b/libcurl_http_fetcher.h @@ -151,11 +151,13 @@ class LibcurlHttpFetcher : public HttpFetcher { void SetupMessageLoopSources(); // Callback called by libcurl when new data has arrived on the transfer - size_t LibcurlWrite(void *ptr, size_t size, size_t nmemb); - static size_t StaticLibcurlWrite(void *ptr, size_t size, - size_t nmemb, void *stream) { - return reinterpret_cast<LibcurlHttpFetcher*>(stream)-> - LibcurlWrite(ptr, size, nmemb); + size_t LibcurlWrite(void* ptr, size_t size, size_t nmemb); + static size_t StaticLibcurlWrite(void* ptr, + size_t size, + size_t nmemb, + void* stream) { + return reinterpret_cast<LibcurlHttpFetcher*>(stream)->LibcurlWrite( + ptr, size, nmemb); } // Cleans up the following if they are non-null: @@ -108,9 +108,8 @@ void SetupLogSymlink(const string& symlink_path, const string& log_path) { // we stop caring about the old-style logs. if (utils::FileExists(symlink_path.c_str()) && !utils::IsSymlink(symlink_path.c_str())) { - base::ReplaceFile(base::FilePath(symlink_path), - base::FilePath(log_path), - nullptr); + base::ReplaceFile( + base::FilePath(symlink_path), base::FilePath(log_path), nullptr); } base::DeleteFile(base::FilePath(symlink_path), true); if (symlink(log_path.c_str(), symlink_path.c_str()) == -1) { @@ -160,10 +159,10 @@ void SetupLogging(bool log_to_system, bool log_to_file) { int main(int argc, char** argv) { DEFINE_bool(logtofile, false, "Write logs to a file in log_dir."); - DEFINE_bool(logtostderr, false, + DEFINE_bool(logtostderr, + false, "Write logs to stderr instead of to a file in log_dir."); - DEFINE_bool(foreground, false, - "Don't daemon()ize; run in foreground."); + DEFINE_bool(foreground, false, "Don't daemon()ize; run in foreground."); chromeos_update_engine::Terminator::Init(); brillo::FlagHelper::Init(argc, argv, "A/B Update Engine"); diff --git a/metrics_reporter_omaha.cc b/metrics_reporter_omaha.cc index 3ae4f4b9..14819d88 100644 --- a/metrics_reporter_omaha.cc +++ b/metrics_reporter_omaha.cc @@ -300,8 +300,6 @@ void MetricsReporterOmaha::ReportUpdateAttemptMetrics( 1024, // max: 1024 MiB = 1 GiB 50); // num_buckets - - metric = metrics::kMetricAttemptResult; LOG(INFO) << "Uploading " << static_cast<int>(attempt_result) << " for metric " << metric; diff --git a/metrics_reporter_omaha_unittest.cc b/metrics_reporter_omaha_unittest.cc index a4790282..545d02f4 100644 --- a/metrics_reporter_omaha_unittest.cc +++ b/metrics_reporter_omaha_unittest.cc @@ -226,7 +226,6 @@ TEST_F(MetricsReporterOmahaTest, ReportUpdateAttemptMetrics) { _)) .Times(2); - // Check the report of attempt result. EXPECT_CALL( *mock_metrics_lib_, diff --git a/metrics_utils_unittest.cc b/metrics_utils_unittest.cc index 417a72b1..e7c4c26b 100644 --- a/metrics_utils_unittest.cc +++ b/metrics_utils_unittest.cc @@ -38,12 +38,12 @@ TEST(MetricsUtilsTest, GetConnectionType) { EXPECT_EQ(metrics::ConnectionType::kEthernet, GetConnectionType(ConnectionType::kEthernet, ConnectionTethering::kUnknown)); - EXPECT_EQ(metrics::ConnectionType::kWifi, - GetConnectionType(ConnectionType::kWifi, - ConnectionTethering::kUnknown)); - EXPECT_EQ(metrics::ConnectionType::kWimax, - GetConnectionType(ConnectionType::kWimax, - ConnectionTethering::kUnknown)); + EXPECT_EQ( + metrics::ConnectionType::kWifi, + GetConnectionType(ConnectionType::kWifi, ConnectionTethering::kUnknown)); + EXPECT_EQ( + metrics::ConnectionType::kWimax, + GetConnectionType(ConnectionType::kWimax, ConnectionTethering::kUnknown)); EXPECT_EQ(metrics::ConnectionType::kBluetooth, GetConnectionType(ConnectionType::kBluetooth, ConnectionTethering::kUnknown)); @@ -75,9 +75,9 @@ TEST(MetricsUtilsTest, GetConnectionType) { EXPECT_EQ(metrics::ConnectionType::kWifi, GetConnectionType(ConnectionType::kWifi, ConnectionTethering::kSuspected)); - EXPECT_EQ(metrics::ConnectionType::kWifi, - GetConnectionType(ConnectionType::kWifi, - ConnectionTethering::kUnknown)); + EXPECT_EQ( + metrics::ConnectionType::kWifi, + GetConnectionType(ConnectionType::kWifi, ConnectionTethering::kUnknown)); } TEST(MetricsUtilsTest, WallclockDurationHelper) { @@ -94,61 +94,51 @@ TEST(MetricsUtilsTest, WallclockDurationHelper) { fake_clock.SetWallclockTime(base::Time::FromInternalValue(1000000)); // First time called so no previous measurement available. - EXPECT_FALSE(metrics_utils::WallclockDurationHelper(&fake_system_state, - state_variable_key, - &duration)); + EXPECT_FALSE(metrics_utils::WallclockDurationHelper( + &fake_system_state, state_variable_key, &duration)); // Next time, we should get zero since the clock didn't advance. - EXPECT_TRUE(metrics_utils::WallclockDurationHelper(&fake_system_state, - state_variable_key, - &duration)); + EXPECT_TRUE(metrics_utils::WallclockDurationHelper( + &fake_system_state, state_variable_key, &duration)); EXPECT_EQ(duration.InSeconds(), 0); // We can also call it as many times as we want with it being // considered a failure. - EXPECT_TRUE(metrics_utils::WallclockDurationHelper(&fake_system_state, - state_variable_key, - &duration)); + EXPECT_TRUE(metrics_utils::WallclockDurationHelper( + &fake_system_state, state_variable_key, &duration)); EXPECT_EQ(duration.InSeconds(), 0); - EXPECT_TRUE(metrics_utils::WallclockDurationHelper(&fake_system_state, - state_variable_key, - &duration)); + EXPECT_TRUE(metrics_utils::WallclockDurationHelper( + &fake_system_state, state_variable_key, &duration)); EXPECT_EQ(duration.InSeconds(), 0); // Advance the clock one second, then we should get 1 sec on the // next call and 0 sec on the subsequent call. fake_clock.SetWallclockTime(base::Time::FromInternalValue(2000000)); - EXPECT_TRUE(metrics_utils::WallclockDurationHelper(&fake_system_state, - state_variable_key, - &duration)); + EXPECT_TRUE(metrics_utils::WallclockDurationHelper( + &fake_system_state, state_variable_key, &duration)); EXPECT_EQ(duration.InSeconds(), 1); - EXPECT_TRUE(metrics_utils::WallclockDurationHelper(&fake_system_state, - state_variable_key, - &duration)); + EXPECT_TRUE(metrics_utils::WallclockDurationHelper( + &fake_system_state, state_variable_key, &duration)); EXPECT_EQ(duration.InSeconds(), 0); // Advance clock two seconds and we should get 2 sec and then 0 sec. fake_clock.SetWallclockTime(base::Time::FromInternalValue(4000000)); - EXPECT_TRUE(metrics_utils::WallclockDurationHelper(&fake_system_state, - state_variable_key, - &duration)); + EXPECT_TRUE(metrics_utils::WallclockDurationHelper( + &fake_system_state, state_variable_key, &duration)); EXPECT_EQ(duration.InSeconds(), 2); - EXPECT_TRUE(metrics_utils::WallclockDurationHelper(&fake_system_state, - state_variable_key, - &duration)); + EXPECT_TRUE(metrics_utils::WallclockDurationHelper( + &fake_system_state, state_variable_key, &duration)); EXPECT_EQ(duration.InSeconds(), 0); // There's a possibility that the wallclock can go backwards (NTP // adjustments, for example) so check that we properly handle this // case. fake_clock.SetWallclockTime(base::Time::FromInternalValue(3000000)); - EXPECT_FALSE(metrics_utils::WallclockDurationHelper(&fake_system_state, - state_variable_key, - &duration)); + EXPECT_FALSE(metrics_utils::WallclockDurationHelper( + &fake_system_state, state_variable_key, &duration)); fake_clock.SetWallclockTime(base::Time::FromInternalValue(4000000)); - EXPECT_TRUE(metrics_utils::WallclockDurationHelper(&fake_system_state, - state_variable_key, - &duration)); + EXPECT_TRUE(metrics_utils::WallclockDurationHelper( + &fake_system_state, state_variable_key, &duration)); EXPECT_EQ(duration.InSeconds(), 1); } @@ -164,48 +154,40 @@ TEST(MetricsUtilsTest, MonotonicDurationHelper) { fake_clock.SetMonotonicTime(base::Time::FromInternalValue(1000000)); // First time called so no previous measurement available. - EXPECT_FALSE(metrics_utils::MonotonicDurationHelper(&fake_system_state, - &storage, - &duration)); + EXPECT_FALSE(metrics_utils::MonotonicDurationHelper( + &fake_system_state, &storage, &duration)); // Next time, we should get zero since the clock didn't advance. - EXPECT_TRUE(metrics_utils::MonotonicDurationHelper(&fake_system_state, - &storage, - &duration)); + EXPECT_TRUE(metrics_utils::MonotonicDurationHelper( + &fake_system_state, &storage, &duration)); EXPECT_EQ(duration.InSeconds(), 0); // We can also call it as many times as we want with it being // considered a failure. - EXPECT_TRUE(metrics_utils::MonotonicDurationHelper(&fake_system_state, - &storage, - &duration)); + EXPECT_TRUE(metrics_utils::MonotonicDurationHelper( + &fake_system_state, &storage, &duration)); EXPECT_EQ(duration.InSeconds(), 0); - EXPECT_TRUE(metrics_utils::MonotonicDurationHelper(&fake_system_state, - &storage, - &duration)); + EXPECT_TRUE(metrics_utils::MonotonicDurationHelper( + &fake_system_state, &storage, &duration)); EXPECT_EQ(duration.InSeconds(), 0); // Advance the clock one second, then we should get 1 sec on the // next call and 0 sec on the subsequent call. fake_clock.SetMonotonicTime(base::Time::FromInternalValue(2000000)); - EXPECT_TRUE(metrics_utils::MonotonicDurationHelper(&fake_system_state, - &storage, - &duration)); + EXPECT_TRUE(metrics_utils::MonotonicDurationHelper( + &fake_system_state, &storage, &duration)); EXPECT_EQ(duration.InSeconds(), 1); - EXPECT_TRUE(metrics_utils::MonotonicDurationHelper(&fake_system_state, - &storage, - &duration)); + EXPECT_TRUE(metrics_utils::MonotonicDurationHelper( + &fake_system_state, &storage, &duration)); EXPECT_EQ(duration.InSeconds(), 0); // Advance clock two seconds and we should get 2 sec and then 0 sec. fake_clock.SetMonotonicTime(base::Time::FromInternalValue(4000000)); - EXPECT_TRUE(metrics_utils::MonotonicDurationHelper(&fake_system_state, - &storage, - &duration)); + EXPECT_TRUE(metrics_utils::MonotonicDurationHelper( + &fake_system_state, &storage, &duration)); EXPECT_EQ(duration.InSeconds(), 2); - EXPECT_TRUE(metrics_utils::MonotonicDurationHelper(&fake_system_state, - &storage, - &duration)); + EXPECT_TRUE(metrics_utils::MonotonicDurationHelper( + &fake_system_state, &storage, &duration)); EXPECT_EQ(duration.InSeconds(), 0); } diff --git a/mock_omaha_request_params.h b/mock_omaha_request_params.h index 2fe5e01d..41bdc195 100644 --- a/mock_omaha_request_params.h +++ b/mock_omaha_request_params.h @@ -33,8 +33,8 @@ class MockOmahaRequestParams : public OmahaRequestParams { // migration from tests using the real RequestParams when they should have // use a fake or mock. ON_CALL(*this, GetAppId()) - .WillByDefault(testing::Invoke( - this, &MockOmahaRequestParams::FakeGetAppId)); + .WillByDefault( + testing::Invoke(this, &MockOmahaRequestParams::FakeGetAppId)); ON_CALL(*this, SetTargetChannel(testing::_, testing::_, testing::_)) .WillByDefault(testing::Invoke( this, &MockOmahaRequestParams::FakeSetTargetChannel)); @@ -47,9 +47,10 @@ class MockOmahaRequestParams : public OmahaRequestParams { } MOCK_CONST_METHOD0(GetAppId, std::string(void)); - MOCK_METHOD3(SetTargetChannel, bool(const std::string& channel, - bool is_powerwash_allowed, - std::string* error)); + MOCK_METHOD3(SetTargetChannel, + bool(const std::string& channel, + bool is_powerwash_allowed, + std::string* error)); MOCK_CONST_METHOD0(target_version_prefix, std::string(void)); MOCK_METHOD0(UpdateDownloadChannel, void(void)); MOCK_CONST_METHOD0(IsUpdateUrlOfficial, bool(void)); @@ -58,16 +59,13 @@ class MockOmahaRequestParams : public OmahaRequestParams { private: // Wrappers to call the parent class and behave like the real object by // default. See "Delegating Calls to a Parent Class" in gmock's documentation. - std::string FakeGetAppId() const { - return OmahaRequestParams::GetAppId(); - } + std::string FakeGetAppId() const { return OmahaRequestParams::GetAppId(); } bool FakeSetTargetChannel(const std::string& channel, bool is_powerwash_allowed, std::string* error) { - return OmahaRequestParams::SetTargetChannel(channel, - is_powerwash_allowed, - error); + return OmahaRequestParams::SetTargetChannel( + channel, is_powerwash_allowed, error); } void FakeUpdateDownloadChannel() { diff --git a/mock_p2p_manager.h b/mock_p2p_manager.h index 5f4418ee..fd670345 100644 --- a/mock_p2p_manager.h +++ b/mock_p2p_manager.h @@ -31,45 +31,41 @@ class MockP2PManager : public P2PManager { MockP2PManager() { // Delegate all calls to the fake instance ON_CALL(*this, SetDevicePolicy(testing::_)) - .WillByDefault(testing::Invoke(&fake_, - &FakeP2PManager::SetDevicePolicy)); + .WillByDefault( + testing::Invoke(&fake_, &FakeP2PManager::SetDevicePolicy)); ON_CALL(*this, IsP2PEnabled()) - .WillByDefault(testing::Invoke(&fake_, - &FakeP2PManager::IsP2PEnabled)); + .WillByDefault(testing::Invoke(&fake_, &FakeP2PManager::IsP2PEnabled)); ON_CALL(*this, EnsureP2PRunning()) - .WillByDefault(testing::Invoke(&fake_, - &FakeP2PManager::EnsureP2PRunning)); + .WillByDefault( + testing::Invoke(&fake_, &FakeP2PManager::EnsureP2PRunning)); ON_CALL(*this, EnsureP2PNotRunning()) - .WillByDefault(testing::Invoke(&fake_, - &FakeP2PManager::EnsureP2PNotRunning)); + .WillByDefault( + testing::Invoke(&fake_, &FakeP2PManager::EnsureP2PNotRunning)); ON_CALL(*this, PerformHousekeeping()) - .WillByDefault(testing::Invoke(&fake_, - &FakeP2PManager::PerformHousekeeping)); - ON_CALL(*this, LookupUrlForFile(testing::_, testing::_, testing::_, - testing::_)) - .WillByDefault(testing::Invoke(&fake_, - &FakeP2PManager::LookupUrlForFile)); + .WillByDefault( + testing::Invoke(&fake_, &FakeP2PManager::PerformHousekeeping)); + ON_CALL(*this, + LookupUrlForFile(testing::_, testing::_, testing::_, testing::_)) + .WillByDefault( + testing::Invoke(&fake_, &FakeP2PManager::LookupUrlForFile)); ON_CALL(*this, FileShare(testing::_, testing::_)) - .WillByDefault(testing::Invoke(&fake_, - &FakeP2PManager::FileShare)); + .WillByDefault(testing::Invoke(&fake_, &FakeP2PManager::FileShare)); ON_CALL(*this, FileGetPath(testing::_)) - .WillByDefault(testing::Invoke(&fake_, - &FakeP2PManager::FileGetPath)); + .WillByDefault(testing::Invoke(&fake_, &FakeP2PManager::FileGetPath)); ON_CALL(*this, FileGetSize(testing::_)) - .WillByDefault(testing::Invoke(&fake_, - &FakeP2PManager::FileGetSize)); + .WillByDefault(testing::Invoke(&fake_, &FakeP2PManager::FileGetSize)); ON_CALL(*this, FileGetExpectedSize(testing::_)) - .WillByDefault(testing::Invoke(&fake_, - &FakeP2PManager::FileGetExpectedSize)); + .WillByDefault( + testing::Invoke(&fake_, &FakeP2PManager::FileGetExpectedSize)); ON_CALL(*this, FileGetVisible(testing::_, testing::_)) - .WillByDefault(testing::Invoke(&fake_, - &FakeP2PManager::FileGetVisible)); + .WillByDefault( + testing::Invoke(&fake_, &FakeP2PManager::FileGetVisible)); ON_CALL(*this, FileMakeVisible(testing::_)) - .WillByDefault(testing::Invoke(&fake_, - &FakeP2PManager::FileMakeVisible)); + .WillByDefault( + testing::Invoke(&fake_, &FakeP2PManager::FileMakeVisible)); ON_CALL(*this, CountSharedFiles()) - .WillByDefault(testing::Invoke(&fake_, - &FakeP2PManager::CountSharedFiles)); + .WillByDefault( + testing::Invoke(&fake_, &FakeP2PManager::CountSharedFiles)); } ~MockP2PManager() override {} @@ -80,10 +76,9 @@ class MockP2PManager : public P2PManager { MOCK_METHOD0(EnsureP2PRunning, bool()); MOCK_METHOD0(EnsureP2PNotRunning, bool()); MOCK_METHOD0(PerformHousekeeping, bool()); - MOCK_METHOD4(LookupUrlForFile, void(const std::string&, - size_t, - base::TimeDelta, - LookupCallback)); + MOCK_METHOD4( + LookupUrlForFile, + void(const std::string&, size_t, base::TimeDelta, LookupCallback)); MOCK_METHOD2(FileShare, bool(const std::string&, size_t)); MOCK_METHOD1(FileGetPath, base::FilePath(const std::string&)); MOCK_METHOD1(FileGetSize, ssize_t(const std::string&)); @@ -93,9 +88,7 @@ class MockP2PManager : public P2PManager { MOCK_METHOD0(CountSharedFiles, int()); // Returns a reference to the underlying FakeP2PManager. - FakeP2PManager& fake() { - return fake_; - } + FakeP2PManager& fake() { return fake_; } private: // The underlying FakeP2PManager. diff --git a/mock_payload_state.h b/mock_payload_state.h index 4ac3ccfe..ad22de52 100644 --- a/mock_payload_state.h +++ b/mock_payload_state.h @@ -26,11 +26,9 @@ namespace chromeos_update_engine { -class MockPayloadState: public PayloadStateInterface { +class MockPayloadState : public PayloadStateInterface { public: - bool Initialize(SystemState* system_state) { - return true; - } + bool Initialize(SystemState* system_state) { return true; } // Significant methods. MOCK_METHOD1(SetResponse, void(const OmahaResponse& response)); diff --git a/network_selector_interface.h b/network_selector_interface.h index 6c17b2cc..bd0948f9 100644 --- a/network_selector_interface.h +++ b/network_selector_interface.h @@ -32,7 +32,6 @@ extern const NetworkId kDefaultNetworkId; class NetworkSelectorInterface { public: - virtual ~NetworkSelectorInterface() = default; // Set the current process network. All sockets created in the future will be diff --git a/omaha_request_action.cc b/omaha_request_action.cc index 9cb9b496..fae9471c 100644 --- a/omaha_request_action.cc +++ b/omaha_request_action.cc @@ -156,7 +156,7 @@ string GetAppBody(const OmahaEvent* event, string app_body; if (event == nullptr) { if (include_ping) - app_body = GetPingXml(ping_active_days, ping_roll_call_days); + app_body = GetPingXml(ping_active_days, ping_roll_call_days); if (!ping_only) { if (!skip_updatecheck) { app_body += " <updatecheck"; @@ -209,7 +209,9 @@ string GetAppBody(const OmahaEvent* event, } app_body = base::StringPrintf( " <event eventtype=\"%d\" eventresult=\"%d\"%s></event>\n", - event->type, event->result, error_code.c_str()); + event->type, + event->result, + error_code.c_str()); } return app_body; @@ -245,8 +247,8 @@ string GetCohortArgXml(PrefsInterface* prefs, return ""; } - return base::StringPrintf("%s=\"%s\" ", - arg_name.c_str(), escaped_xml_value.c_str()); + return base::StringPrintf( + "%s=\"%s\" ", arg_name.c_str(), escaped_xml_value.c_str()); } struct OmahaAppData { @@ -302,8 +304,8 @@ string GetAppXml(const OmahaEvent* event, string app_channels = "track=\"" + XmlEncodeWithDefault(download_channel, "") + "\" "; if (params->current_channel() != download_channel) { - app_channels += "from_track=\"" + XmlEncodeWithDefault( - params->current_channel(), "") + "\" "; + app_channels += "from_track=\"" + + XmlEncodeWithDefault(params->current_channel(), "") + "\" "; } string delta_okay_str = params->delta_okay() ? "true" : "false"; @@ -312,17 +314,17 @@ string GetAppXml(const OmahaEvent* event, // include the attribute. string install_date_in_days_str = ""; if (install_date_in_days >= 0) { - install_date_in_days_str = base::StringPrintf("installdate=\"%d\" ", - install_date_in_days); + install_date_in_days_str = + base::StringPrintf("installdate=\"%d\" ", install_date_in_days); } string app_cohort_args; - app_cohort_args += GetCohortArgXml(system_state->prefs(), - "cohort", kPrefsOmahaCohort); - app_cohort_args += GetCohortArgXml(system_state->prefs(), - "cohorthint", kPrefsOmahaCohortHint); - app_cohort_args += GetCohortArgXml(system_state->prefs(), - "cohortname", kPrefsOmahaCohortName); + app_cohort_args += + GetCohortArgXml(system_state->prefs(), "cohort", kPrefsOmahaCohort); + app_cohort_args += GetCohortArgXml( + system_state->prefs(), "cohorthint", kPrefsOmahaCohortHint); + app_cohort_args += GetCohortArgXml( + system_state->prefs(), "cohortname", kPrefsOmahaCohortName); string fingerprint_arg; if (!params->os_build_fingerprint().empty()) { @@ -389,10 +391,13 @@ string GetAppXml(const OmahaEvent* event, // Returns an XML that corresponds to the entire <os> node of the Omaha // request based on the given parameters. string GetOsXml(OmahaRequestParams* params) { - string os_xml =" <os " - "version=\"" + XmlEncodeWithDefault(params->os_version(), "") + "\" " + - "platform=\"" + XmlEncodeWithDefault(params->os_platform(), "") + "\" " + - "sp=\"" + XmlEncodeWithDefault(params->os_sp(), "") + "\">" + string os_xml = + " <os " + "version=\"" + + XmlEncodeWithDefault(params->os_version(), "") + "\" " + "platform=\"" + + XmlEncodeWithDefault(params->os_platform(), "") + "\" " + "sp=\"" + + XmlEncodeWithDefault(params->os_sp(), "") + + "\">" "</os>\n"; return os_xml; } @@ -455,23 +460,22 @@ string GetRequestXml(const OmahaEvent* event, system_state); } - string install_source = base::StringPrintf("installsource=\"%s\" ", + string install_source = base::StringPrintf( + "installsource=\"%s\" ", (params->interactive() ? "ondemandupdate" : "scheduler")); string updater_version = XmlEncodeWithDefault( - base::StringPrintf("%s-%s", - constants::kOmahaUpdaterID, - kOmahaUpdaterVersion), ""); + base::StringPrintf( + "%s-%s", constants::kOmahaUpdaterID, kOmahaUpdaterVersion), + ""); string request_xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" - "<request protocol=\"3.0\" " + ( - "version=\"" + updater_version + "\" " - "updaterversion=\"" + updater_version + "\" " + - install_source + - "ismachine=\"1\">\n") + - os_xml + - app_xml + - "</request>\n"; + "<request protocol=\"3.0\" " + + ("version=\"" + updater_version + + "\" " + "updaterversion=\"" + + updater_version + "\" " + install_source + "ismachine=\"1\">\n") + + os_xml + app_xml + "</request>\n"; return request_xml; } @@ -522,7 +526,8 @@ struct OmahaParserData { namespace { // Callback function invoked by expat. -void ParserHandlerStart(void* user_data, const XML_Char* element, +void ParserHandlerStart(void* user_data, + const XML_Char* element, const XML_Char** attr) { OmahaParserData* data = reinterpret_cast<OmahaParserData*>(user_data); @@ -533,7 +538,7 @@ void ParserHandlerStart(void* user_data, const XML_Char* element, map<string, string> attrs; if (attr != nullptr) { - for (int n = 0; attr[n] != nullptr && attr[n+1] != nullptr; n += 2) { + for (int n = 0; attr[n] != nullptr && attr[n + 1] != nullptr; n += 2) { string key = attr[n]; string value = attr[n + 1]; attrs[key] = value; @@ -605,8 +610,8 @@ void ParserHandlerEnd(void* user_data, const XML_Char* element) { const string path_suffix = string("/") + element; - if (!base::EndsWith(data->current_path, path_suffix, - base::CompareCase::SENSITIVE)) { + if (!base::EndsWith( + data->current_path, path_suffix, base::CompareCase::SENSITIVE)) { LOG(ERROR) << "Unexpected end element '" << element << "' with current_path='" << data->current_path << "'"; data->failed = true; @@ -621,15 +626,15 @@ void ParserHandlerEnd(void* user_data, const XML_Char* element) { // to never return any XML with entities our course of action is to // just stop parsing. This avoids potential resource exhaustion // problems AKA the "billion laughs". CVE-2013-0340. -void ParserHandlerEntityDecl(void *user_data, - const XML_Char *entity_name, +void ParserHandlerEntityDecl(void* user_data, + const XML_Char* entity_name, int is_parameter_entity, - const XML_Char *value, + const XML_Char* value, int value_length, - const XML_Char *base, - const XML_Char *system_id, - const XML_Char *public_id, - const XML_Char *notation_name) { + const XML_Char* base, + const XML_Char* system_id, + const XML_Char* public_id, + const XML_Char* notation_name) { OmahaParserData* data = reinterpret_cast<OmahaParserData*>(user_data); LOG(ERROR) << "XML entities are not supported. Aborting parsing."; @@ -641,8 +646,9 @@ void ParserHandlerEntityDecl(void *user_data, } // namespace bool XmlEncode(const string& input, string* output) { - if (std::find_if(input.begin(), input.end(), - [](const char c){return c & 0x80;}) != input.end()) { + if (std::find_if(input.begin(), input.end(), [](const char c) { + return c & 0x80; + }) != input.end()) { LOG(WARNING) << "Invalid ASCII-7 string passed to the XML encoder:"; utils::HexDumpString(input); return false; @@ -713,8 +719,8 @@ int OmahaRequestAction::CalculatePingDays(const string& key) { // last ping daystart preference. This way the next ping time // will be correct, hopefully. days = kPingTimeJump; - LOG(WARNING) << - "System clock jumped back in time. Resetting ping daystarts."; + LOG(WARNING) + << "System clock jumped back in time. Resetting ping daystarts."; } } return days; @@ -805,13 +811,12 @@ int OmahaRequestAction::GetInstallDate(SystemState* system_state) { } // Persist this to disk, for future use. - if (!OmahaRequestAction::PersistInstallDate(system_state, - num_days, - kProvisionedFromOOBEMarker)) + if (!OmahaRequestAction::PersistInstallDate( + system_state, num_days, kProvisionedFromOOBEMarker)) return -1; - LOG(INFO) << "Set the Omaha InstallDate from OOBE time-stamp to " - << num_days << " days"; + LOG(INFO) << "Set the Omaha InstallDate from OOBE time-stamp to " << num_days + << " days"; return num_days; } @@ -842,8 +847,8 @@ void OmahaRequestAction::PerformAction() { base::StringPrintf( "%s-%s", constants::kOmahaUpdaterID, kOmahaUpdaterVersion)); - http_fetcher_->SetPostData(request_post.data(), request_post.size(), - kHttpContentTypeTextXml); + http_fetcher_->SetPostData( + request_post.data(), request_post.size(), kHttpContentTypeTextXml); LOG(INFO) << "Posting an Omaha request to " << params_->update_url(); LOG(INFO) << "Request: " << request_post; http_fetcher_->BeginTransfer(params_->update_url()); @@ -885,11 +890,10 @@ bool ParseBool(const string& str) { // Update the last ping day preferences based on the server daystart // response. Returns true on success, false otherwise. -bool UpdateLastPingDays(OmahaParserData *parser_data, PrefsInterface* prefs) { +bool UpdateLastPingDays(OmahaParserData* parser_data, PrefsInterface* prefs) { int64_t elapsed_seconds = 0; - TEST_AND_RETURN_FALSE( - base::StringToInt64(parser_data->daystart_elapsed_seconds, - &elapsed_seconds)); + TEST_AND_RETURN_FALSE(base::StringToInt64( + parser_data->daystart_elapsed_seconds, &elapsed_seconds)); TEST_AND_RETURN_FALSE(elapsed_seconds >= 0); // Remember the local time that matches the server's last midnight @@ -1204,7 +1208,7 @@ bool OmahaRequestAction::ParseParams(OmahaParserData* parser_data, // If the transfer was successful, this uses expat to parse the response // and fill in the appropriate fields of the output object. Also, notifies // the processor that we're done. -void OmahaRequestAction::TransferComplete(HttpFetcher *fetcher, +void OmahaRequestAction::TransferComplete(HttpFetcher* fetcher, bool successful) { ScopedActionCompleter completer(processor_, this); string current_response(response_buffer_.begin(), response_buffer_.end()); @@ -1239,17 +1243,17 @@ void OmahaRequestAction::TransferComplete(HttpFetcher *fetcher, XML_SetUserData(parser, &parser_data); XML_SetElementHandler(parser, ParserHandlerStart, ParserHandlerEnd); XML_SetEntityDeclHandler(parser, ParserHandlerEntityDecl); - XML_Status res = XML_Parse( - parser, - reinterpret_cast<const char*>(response_buffer_.data()), - response_buffer_.size(), - XML_TRUE); + XML_Status res = + XML_Parse(parser, + reinterpret_cast<const char*>(response_buffer_.data()), + response_buffer_.size(), + XML_TRUE); if (res != XML_STATUS_OK || parser_data.failed) { LOG(ERROR) << "Omaha response not valid XML: " - << XML_ErrorString(XML_GetErrorCode(parser)) - << " at line " << XML_GetCurrentLineNumber(parser) - << " col " << XML_GetCurrentColumnNumber(parser); + << XML_ErrorString(XML_GetErrorCode(parser)) << " at line " + << XML_GetCurrentLineNumber(parser) << " col " + << XML_GetCurrentColumnNumber(parser); XML_ParserFree(parser); ErrorCode error_code = ErrorCode::kOmahaRequestXMLParseError; if (response_buffer_.empty()) { @@ -1304,7 +1308,6 @@ void OmahaRequestAction::TransferComplete(HttpFetcher *fetcher, return; } - // If Omaha says to disable p2p, respect that if (output_object.disable_p2p_for_downloading) { LOG(INFO) << "Forcibly disabling use of p2p for downloading as " @@ -1555,9 +1558,9 @@ OmahaRequestAction::IsWallClockBasedWaitingSatisfied( // But we can't download until the update-check-count-based wait is also // satisfied, so mark it as required now if update checks are enabled. - return params_->update_check_count_wait_enabled() ? - kWallClockWaitDoneButUpdateCheckWaitRequired : - kWallClockWaitDoneAndUpdateCheckWaitNotRequired; + return params_->update_check_count_wait_enabled() + ? kWallClockWaitDoneButUpdateCheckWaitRequired + : kWallClockWaitDoneAndUpdateCheckWaitNotRequired; } // Not our turn yet, so we have to wait until our turn to @@ -1583,9 +1586,9 @@ bool OmahaRequestAction::IsUpdateCheckCountBasedWaitingSatisfied() { } else { // This file does not exist. This means we haven't started our update // check count down yet, so this is the right time to start the count down. - update_check_count_value = base::RandInt( - params_->min_update_checks_needed(), - params_->max_update_checks_allowed()); + update_check_count_value = + base::RandInt(params_->min_update_checks_needed(), + params_->max_update_checks_allowed()); LOG(INFO) << "Randomly picked update check count value = " << update_check_count_value; @@ -1618,8 +1621,7 @@ bool OmahaRequestAction::IsUpdateCheckCountBasedWaitingSatisfied() { // Legal value, we need to wait for more update checks to happen // until this becomes 0. LOG(INFO) << "Deferring Omaha updates for another " - << update_check_count_value - << " update checks per policy"; + << update_check_count_value << " update checks per policy"; return false; } @@ -1627,8 +1629,7 @@ bool OmahaRequestAction::IsUpdateCheckCountBasedWaitingSatisfied() { bool OmahaRequestAction::ParseInstallDate(OmahaParserData* parser_data, OmahaResponse* output_object) { int64_t elapsed_days = 0; - if (!base::StringToInt64(parser_data->daystart_elapsed_days, - &elapsed_days)) + if (!base::StringToInt64(parser_data->daystart_elapsed_days, &elapsed_days)) return false; if (elapsed_days < 0) @@ -1639,7 +1640,7 @@ bool OmahaRequestAction::ParseInstallDate(OmahaParserData* parser_data, } // static -bool OmahaRequestAction::HasInstallDate(SystemState *system_state) { +bool OmahaRequestAction::HasInstallDate(SystemState* system_state) { PrefsInterface* prefs = system_state->prefs(); if (prefs == nullptr) return false; @@ -1649,7 +1650,7 @@ bool OmahaRequestAction::HasInstallDate(SystemState *system_state) { // static bool OmahaRequestAction::PersistInstallDate( - SystemState *system_state, + SystemState* system_state, int install_date_days, InstallDateProvisioningSource source) { TEST_AND_RETURN_FALSE(install_date_days >= 0); @@ -1667,9 +1668,8 @@ bool OmahaRequestAction::PersistInstallDate( return true; } -bool OmahaRequestAction::PersistCohortData( - const string& prefs_key, - const string& new_value) { +bool OmahaRequestAction::PersistCohortData(const string& prefs_key, + const string& new_value) { if (new_value.empty() && system_state_->prefs()->Exists(prefs_key)) { LOG(INFO) << "Removing stored " << prefs_key << " value."; return system_state_->prefs()->Delete(prefs_key); @@ -1703,51 +1703,51 @@ void OmahaRequestAction::ActionCompleted(ErrorCode code) { // Regular update attempt. switch (code) { - case ErrorCode::kSuccess: - // OK, we parsed the response successfully but that does - // necessarily mean that an update is available. - if (HasOutputPipe()) { - const OmahaResponse& response = GetOutputObject(); - if (response.update_exists) { - result = metrics::CheckResult::kUpdateAvailable; - reaction = metrics::CheckReaction::kUpdating; + case ErrorCode::kSuccess: + // OK, we parsed the response successfully but that does + // necessarily mean that an update is available. + if (HasOutputPipe()) { + const OmahaResponse& response = GetOutputObject(); + if (response.update_exists) { + result = metrics::CheckResult::kUpdateAvailable; + reaction = metrics::CheckReaction::kUpdating; + } else { + result = metrics::CheckResult::kNoUpdateAvailable; + } } else { result = metrics::CheckResult::kNoUpdateAvailable; } - } else { - result = metrics::CheckResult::kNoUpdateAvailable; - } - break; - - case ErrorCode::kOmahaUpdateIgnoredPerPolicy: - case ErrorCode::kOmahaUpdateIgnoredOverCellular: - result = metrics::CheckResult::kUpdateAvailable; - reaction = metrics::CheckReaction::kIgnored; - break; - - case ErrorCode::kOmahaUpdateDeferredPerPolicy: - result = metrics::CheckResult::kUpdateAvailable; - reaction = metrics::CheckReaction::kDeferring; - break; - - case ErrorCode::kOmahaUpdateDeferredForBackoff: - result = metrics::CheckResult::kUpdateAvailable; - reaction = metrics::CheckReaction::kBackingOff; - break; - - default: - // We report two flavors of errors, "Download errors" and "Parsing - // error". Try to convert to the former and if that doesn't work - // we know it's the latter. - metrics::DownloadErrorCode tmp_error = - metrics_utils::GetDownloadErrorCode(code); - if (tmp_error != metrics::DownloadErrorCode::kInputMalformed) { - result = metrics::CheckResult::kDownloadError; - download_error_code = tmp_error; - } else { - result = metrics::CheckResult::kParsingError; - } - break; + break; + + case ErrorCode::kOmahaUpdateIgnoredPerPolicy: + case ErrorCode::kOmahaUpdateIgnoredOverCellular: + result = metrics::CheckResult::kUpdateAvailable; + reaction = metrics::CheckReaction::kIgnored; + break; + + case ErrorCode::kOmahaUpdateDeferredPerPolicy: + result = metrics::CheckResult::kUpdateAvailable; + reaction = metrics::CheckReaction::kDeferring; + break; + + case ErrorCode::kOmahaUpdateDeferredForBackoff: + result = metrics::CheckResult::kUpdateAvailable; + reaction = metrics::CheckReaction::kBackingOff; + break; + + default: + // We report two flavors of errors, "Download errors" and "Parsing + // error". Try to convert to the former and if that doesn't work + // we know it's the latter. + metrics::DownloadErrorCode tmp_error = + metrics_utils::GetDownloadErrorCode(code); + if (tmp_error != metrics::DownloadErrorCode::kInputMalformed) { + result = metrics::CheckResult::kDownloadError; + download_error_code = tmp_error; + } else { + result = metrics::CheckResult::kParsingError; + } + break; } system_state_->metrics_reporter()->ReportUpdateCheckMetrics( diff --git a/omaha_request_action.h b/omaha_request_action.h index c083abe3..8db5fb9b 100644 --- a/omaha_request_action.h +++ b/omaha_request_action.h @@ -88,9 +88,7 @@ struct OmahaEvent { result(kResultSuccess), error_code(ErrorCode::kSuccess) {} OmahaEvent(Type in_type, Result in_result, ErrorCode in_error_code) - : type(in_type), - result(in_result), - error_code(in_error_code) {} + : type(in_type), result(in_result), error_code(in_error_code) {} Type type; Result result; @@ -105,7 +103,7 @@ class PrefsInterface; // This struct is declared in the .cc file. struct OmahaParserData; -template<> +template <> class ActionTraits<OmahaRequestAction> { public: // Takes parameters on the input pipe. @@ -175,7 +173,7 @@ class OmahaRequestAction : public Action<OmahaRequestAction>, const void* bytes, size_t length) override; - void TransferComplete(HttpFetcher *fetcher, bool successful) override; + void TransferComplete(HttpFetcher* fetcher, bool successful) override; // Returns true if this is an Event request, false if it's an UpdateCheck. bool IsEvent() const { return event_.get() != nullptr; } @@ -215,12 +213,12 @@ class OmahaRequestAction : public Action<OmahaRequestAction>, // Returns True if the kPrefsInstallDateDays state variable is set, // False otherwise. - static bool HasInstallDate(SystemState *system_state); + static bool HasInstallDate(SystemState* system_state); // Writes |install_date_days| into the kPrefsInstallDateDays state // variable and emits an UMA stat for the |source| used. Returns // True if the value was written, False if an error occurred. - static bool PersistInstallDate(SystemState *system_state, + static bool PersistInstallDate(SystemState* system_state, int install_date_days, InstallDateProvisioningSource source); diff --git a/omaha_request_action_unittest.cc b/omaha_request_action_unittest.cc index 9a5cd10d..1786bcc2 100644 --- a/omaha_request_action_unittest.cc +++ b/omaha_request_action_unittest.cc @@ -58,6 +58,7 @@ using base::TimeDelta; using chromeos_update_manager::kRollforwardInfinity; using std::string; using std::vector; +using testing::_; using testing::AllOf; using testing::AnyNumber; using testing::DoAll; @@ -65,11 +66,10 @@ using testing::Ge; using testing::Le; using testing::NiceMock; using testing::Return; -using testing::ReturnRef; using testing::ReturnPointee; +using testing::ReturnRef; using testing::SaveArg; using testing::SetArgPointee; -using testing::_; namespace { @@ -188,9 +188,7 @@ struct FakeUpdateResponse { } // Return the payload URL, which is split in two fields in the XML response. - string GetPayloadUrl() { - return codebase + filename; - } + string GetPayloadUrl() { return codebase + filename; } string app_id = kTestAppId; string app_id2 = kTestAppId2; @@ -376,21 +374,20 @@ class OmahaRequestActionTest : public ::testing::Test { void PingTest(bool ping_only); // InstallDate test helper function. - bool InstallDateParseHelper(const string &elapsed_days, - OmahaResponse *response); + bool InstallDateParseHelper(const string& elapsed_days, + OmahaResponse* response); // P2P test helper function. - void P2PTest( - bool initial_allow_p2p_for_downloading, - bool initial_allow_p2p_for_sharing, - bool omaha_disable_p2p_for_downloading, - bool omaha_disable_p2p_for_sharing, - bool payload_state_allow_p2p_attempt, - bool expect_p2p_client_lookup, - const string& p2p_client_result_url, - bool expected_allow_p2p_for_downloading, - bool expected_allow_p2p_for_sharing, - const string& expected_p2p_url); + void P2PTest(bool initial_allow_p2p_for_downloading, + bool initial_allow_p2p_for_sharing, + bool omaha_disable_p2p_for_downloading, + bool omaha_disable_p2p_for_sharing, + bool payload_state_allow_p2p_attempt, + bool expect_p2p_client_lookup, + const string& p2p_client_result_url, + bool expected_allow_p2p_for_downloading, + bool expected_allow_p2p_for_sharing, + const string& expected_p2p_url); FakeSystemState fake_system_state_; FakeUpdateResponse fake_update_response_; @@ -878,10 +875,9 @@ TEST_F(OmahaRequestActionTest, ValidUpdateBlockedByConnection) { fake_system_state_.set_connection_manager(&mock_cm); EXPECT_CALL(mock_cm, GetConnectionProperties(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(ConnectionType::kEthernet), - SetArgPointee<1>(ConnectionTethering::kUnknown), - Return(true))); + .WillRepeatedly(DoAll(SetArgPointee<0>(ConnectionType::kEthernet), + SetArgPointee<1>(ConnectionTethering::kUnknown), + Return(true))); EXPECT_CALL(mock_cm, IsUpdateAllowedOver(ConnectionType::kEthernet, _)) .WillRepeatedly(Return(false)); @@ -1069,7 +1065,7 @@ TEST_F(OmahaRequestActionTest, ValidUpdateBlockedByRollback) { fake_system_state_.set_payload_state(&mock_payload_state); EXPECT_CALL(mock_payload_state, GetRollbackVersion()) - .WillRepeatedly(Return(rollback_version)); + .WillRepeatedly(Return(rollback_version)); fake_update_response_.version = rollback_version; ASSERT_FALSE(TestUpdateCheck(fake_update_response_.GetUpdateResponse(), @@ -1269,7 +1265,6 @@ TEST_F(OmahaRequestActionTest, ZeroMaxDaysToScatterCausesNoScattering) { EXPECT_TRUE(response.update_exists); } - TEST_F(OmahaRequestActionTest, ZeroUpdateCheckCountCausesNoScattering) { OmahaResponse response; request_params_.set_wall_clock_based_wait_enabled(true); @@ -1280,16 +1275,15 @@ TEST_F(OmahaRequestActionTest, ZeroUpdateCheckCountCausesNoScattering) { fake_system_state_.fake_clock()->SetWallclockTime(Time::Now()); - ASSERT_TRUE(TestUpdateCheck( - fake_update_response_.GetUpdateResponse(), - -1, - false, // ping_only - ErrorCode::kSuccess, - metrics::CheckResult::kUpdateAvailable, - metrics::CheckReaction::kUpdating, - metrics::DownloadErrorCode::kUnset, - &response, - nullptr)); + ASSERT_TRUE(TestUpdateCheck(fake_update_response_.GetUpdateResponse(), + -1, + false, // ping_only + ErrorCode::kSuccess, + metrics::CheckResult::kUpdateAvailable, + metrics::CheckReaction::kUpdating, + metrics::DownloadErrorCode::kUnset, + &response, + nullptr)); int64_t count; ASSERT_TRUE(fake_prefs_.GetInt64(kPrefsUpdateCheckCount, &count)); @@ -1307,16 +1301,15 @@ TEST_F(OmahaRequestActionTest, NonZeroUpdateCheckCountCausesScattering) { fake_system_state_.fake_clock()->SetWallclockTime(Time::Now()); - ASSERT_FALSE(TestUpdateCheck( - fake_update_response_.GetUpdateResponse(), - -1, - false, // ping_only - ErrorCode::kOmahaUpdateDeferredPerPolicy, - metrics::CheckResult::kUpdateAvailable, - metrics::CheckReaction::kDeferring, - metrics::DownloadErrorCode::kUnset, - &response, - nullptr)); + ASSERT_FALSE(TestUpdateCheck(fake_update_response_.GetUpdateResponse(), + -1, + false, // ping_only + ErrorCode::kOmahaUpdateDeferredPerPolicy, + metrics::CheckResult::kUpdateAvailable, + metrics::CheckReaction::kDeferring, + metrics::DownloadErrorCode::kUnset, + &response, + nullptr)); int64_t count; ASSERT_TRUE(fake_prefs_.GetInt64(kPrefsUpdateCheckCount, &count)); @@ -1349,16 +1342,15 @@ TEST_F(OmahaRequestActionTest, ExistingUpdateCheckCountCausesScattering) { ASSERT_TRUE(fake_prefs_.SetInt64(kPrefsUpdateCheckCount, 5)); - ASSERT_FALSE(TestUpdateCheck( - fake_update_response_.GetUpdateResponse(), - -1, - false, // ping_only - ErrorCode::kOmahaUpdateDeferredPerPolicy, - metrics::CheckResult::kUpdateAvailable, - metrics::CheckReaction::kDeferring, - metrics::DownloadErrorCode::kUnset, - &response, - nullptr)); + ASSERT_FALSE(TestUpdateCheck(fake_update_response_.GetUpdateResponse(), + -1, + false, // ping_only + ErrorCode::kOmahaUpdateDeferredPerPolicy, + metrics::CheckResult::kUpdateAvailable, + metrics::CheckReaction::kDeferring, + metrics::DownloadErrorCode::kUnset, + &response, + nullptr)); int64_t count; ASSERT_TRUE(fake_prefs_.GetInt64(kPrefsUpdateCheckCount, &count)); @@ -1774,9 +1766,9 @@ TEST_F(OmahaRequestActionTest, XmlEncodeIsUsedForParams) { request_params_.set_hwid("<OEM MODEL>"); fake_prefs_.SetString(kPrefsOmahaCohort, "evil\nstring"); fake_prefs_.SetString(kPrefsOmahaCohortHint, "evil&string\\"); - fake_prefs_.SetString(kPrefsOmahaCohortName, - base::JoinString( - vector<string>(100, "My spoon is too big."), " ")); + fake_prefs_.SetString( + kPrefsOmahaCohortName, + base::JoinString(vector<string>(100, "My spoon is too big."), " ")); OmahaResponse response; ASSERT_FALSE(TestUpdateCheck("invalid xml>", -1, @@ -1870,15 +1862,12 @@ TEST_F(OmahaRequestActionTest, FormatUpdateCheckOutputTest) { string::npos); EXPECT_NE(post_str.find("hardware_class=\"OEM MODEL 09235 7471\""), string::npos); - EXPECT_NE(post_str.find("fw_version=\"ChromeOSFirmware.1.0\""), - string::npos); - EXPECT_NE(post_str.find("ec_version=\"0X0A1\""), - string::npos); + EXPECT_NE(post_str.find("fw_version=\"ChromeOSFirmware.1.0\""), string::npos); + EXPECT_NE(post_str.find("ec_version=\"0X0A1\""), string::npos); // No <event> tag should be sent if we didn't reboot to an update. EXPECT_EQ(post_str.find("<event"), string::npos); } - TEST_F(OmahaRequestActionTest, FormatSuccessEventOutputTest) { brillo::Blob post_data; TestEvent(new OmahaEvent(OmahaEvent::kTypeUpdateDownloadStarted), @@ -1919,18 +1908,16 @@ TEST_F(OmahaRequestActionTest, IsEventTest) { OmahaRequestAction update_check_action( &fake_system_state_, nullptr, - std::make_unique<MockHttpFetcher>(http_response.data(), - http_response.size(), - nullptr), + std::make_unique<MockHttpFetcher>( + http_response.data(), http_response.size(), nullptr), false); EXPECT_FALSE(update_check_action.IsEvent()); OmahaRequestAction event_action( &fake_system_state_, new OmahaEvent(OmahaEvent::kTypeUpdateComplete), - std::make_unique<MockHttpFetcher>(http_response.data(), - http_response.size(), - nullptr), + std::make_unique<MockHttpFetcher>( + http_response.data(), http_response.size(), nullptr), false); EXPECT_TRUE(event_action.IsEvent()); } @@ -1954,9 +1941,9 @@ TEST_F(OmahaRequestActionTest, FormatDeltaOkayOutputTest) { &post_data)); // convert post_data to string string post_str(post_data.begin(), post_data.end()); - EXPECT_NE(post_str.find(base::StringPrintf(" delta_okay=\"%s\"", - delta_okay_str)), - string::npos) + EXPECT_NE( + post_str.find(base::StringPrintf(" delta_okay=\"%s\"", delta_okay_str)), + string::npos) << "i = " << i; } } @@ -2073,7 +2060,7 @@ void OmahaRequestActionTest::PingTest(bool ping_only) { NiceMock<MockPrefs> prefs; fake_system_state_.set_prefs(&prefs); EXPECT_CALL(prefs, GetInt64(kPrefsMetricsCheckLastReportingTime, _)) - .Times(AnyNumber()); + .Times(AnyNumber()); EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber()); // Add a few hours to the day difference to test no rounding, etc. int64_t five_days_ago = @@ -2109,18 +2096,18 @@ void OmahaRequestActionTest::PingTest(bool ping_only) { } TEST_F(OmahaRequestActionTest, PingTestSendOnlyAPing) { - PingTest(true /* ping_only */); + PingTest(true /* ping_only */); } TEST_F(OmahaRequestActionTest, PingTestSendAlsoAnUpdateCheck) { - PingTest(false /* ping_only */); + PingTest(false /* ping_only */); } TEST_F(OmahaRequestActionTest, ActivePingTest) { NiceMock<MockPrefs> prefs; fake_system_state_.set_prefs(&prefs); EXPECT_CALL(prefs, GetInt64(kPrefsMetricsCheckLastReportingTime, _)) - .Times(AnyNumber()); + .Times(AnyNumber()); EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber()); int64_t three_days_ago = (Time::Now() - TimeDelta::FromHours(3 * 24 + 12)).ToInternalValue(); @@ -2142,15 +2129,14 @@ TEST_F(OmahaRequestActionTest, ActivePingTest) { nullptr, &post_data)); string post_str(post_data.begin(), post_data.end()); - EXPECT_NE(post_str.find("<ping active=\"1\" a=\"3\"></ping>"), - string::npos); + EXPECT_NE(post_str.find("<ping active=\"1\" a=\"3\"></ping>"), string::npos); } TEST_F(OmahaRequestActionTest, RollCallPingTest) { NiceMock<MockPrefs> prefs; fake_system_state_.set_prefs(&prefs); EXPECT_CALL(prefs, GetInt64(kPrefsMetricsCheckLastReportingTime, _)) - .Times(AnyNumber()); + .Times(AnyNumber()); EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber()); int64_t four_days_ago = (Time::Now() - TimeDelta::FromHours(4 * 24)).ToInternalValue(); @@ -2180,7 +2166,7 @@ TEST_F(OmahaRequestActionTest, NoPingTest) { NiceMock<MockPrefs> prefs; fake_system_state_.set_prefs(&prefs); EXPECT_CALL(prefs, GetInt64(kPrefsMetricsCheckLastReportingTime, _)) - .Times(AnyNumber()); + .Times(AnyNumber()); EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber()); int64_t one_hour_ago = (Time::Now() - TimeDelta::FromHours(1)).ToInternalValue(); @@ -2238,7 +2224,7 @@ TEST_F(OmahaRequestActionTest, BackInTimePingTest) { NiceMock<MockPrefs> prefs; fake_system_state_.set_prefs(&prefs); EXPECT_CALL(prefs, GetInt64(kPrefsMetricsCheckLastReportingTime, _)) - .Times(AnyNumber()); + .Times(AnyNumber()); EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber()); int64_t future = (Time::Now() + TimeDelta::FromHours(3 * 24 + 4)).ToInternalValue(); @@ -2283,11 +2269,13 @@ TEST_F(OmahaRequestActionTest, LastPingDayUpdateTest) { fake_system_state_.set_prefs(&prefs); EXPECT_CALL(prefs, GetInt64(_, _)).Times(AnyNumber()); EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber()); - EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay, - AllOf(Ge(midnight), Le(midnight_slack)))) + EXPECT_CALL(prefs, + SetInt64(kPrefsLastActivePingDay, + AllOf(Ge(midnight), Le(midnight_slack)))) .WillOnce(Return(true)); - EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay, - AllOf(Ge(midnight), Le(midnight_slack)))) + EXPECT_CALL(prefs, + SetInt64(kPrefsLastRollCallPingDay, + AllOf(Ge(midnight), Le(midnight_slack)))) .WillOnce(Return(true)); ASSERT_TRUE( TestUpdateCheck("<?xml version=\"1.0\" encoding=\"UTF-8\"?><response " @@ -2516,10 +2504,11 @@ TEST_F(OmahaRequestActionTest, TestChangingToMoreStableChannel) { &post_data)); // convert post_data to string string post_str(post_data.begin(), post_data.end()); - EXPECT_NE(string::npos, post_str.find( - "appid=\"{22222222-2222-2222-2222-222222222222}\" " - "version=\"0.0.0.0\" from_version=\"1.2.3.4\" " - "track=\"stable-channel\" from_track=\"canary-channel\" ")); + EXPECT_NE( + string::npos, + post_str.find("appid=\"{22222222-2222-2222-2222-222222222222}\" " + "version=\"0.0.0.0\" from_version=\"1.2.3.4\" " + "track=\"stable-channel\" from_track=\"canary-channel\" ")); EXPECT_EQ(string::npos, post_str.find("o.bundle")); } @@ -2549,10 +2538,11 @@ TEST_F(OmahaRequestActionTest, TestChangingToLessStableChannel) { &post_data)); // Convert post_data to string. string post_str(post_data.begin(), post_data.end()); - EXPECT_NE(string::npos, post_str.find( - "appid=\"{11111111-1111-1111-1111-111111111111}\" " - "version=\"5.6.7.8\" " - "track=\"canary-channel\" from_track=\"stable-channel\"")); + EXPECT_NE( + string::npos, + post_str.find("appid=\"{11111111-1111-1111-1111-111111111111}\" " + "version=\"5.6.7.8\" " + "track=\"canary-channel\" from_track=\"stable-channel\"")); EXPECT_EQ(string::npos, post_str.find("from_version")); EXPECT_NE(string::npos, post_str.find("o.bundle.version=\"1\"")); } @@ -2625,10 +2615,10 @@ TEST_F(OmahaRequestActionTest, RebootAfterUpdateEvent) { string post_str(post_data.begin(), post_data.end()); // An event 54 is included and has the right version. - EXPECT_NE(string::npos, - post_str.find(base::StringPrintf( - "<event eventtype=\"%d\"", - OmahaEvent::kTypeRebootedAfterUpdate))); + EXPECT_NE( + string::npos, + post_str.find(base::StringPrintf("<event eventtype=\"%d\"", + OmahaEvent::kTypeRebootedAfterUpdate))); EXPECT_NE(string::npos, post_str.find("previousversion=\"1.2.3.4\"></event>")); @@ -2639,17 +2629,16 @@ TEST_F(OmahaRequestActionTest, RebootAfterUpdateEvent) { EXPECT_TRUE(prev_version.empty()); } -void OmahaRequestActionTest::P2PTest( - bool initial_allow_p2p_for_downloading, - bool initial_allow_p2p_for_sharing, - bool omaha_disable_p2p_for_downloading, - bool omaha_disable_p2p_for_sharing, - bool payload_state_allow_p2p_attempt, - bool expect_p2p_client_lookup, - const string& p2p_client_result_url, - bool expected_allow_p2p_for_downloading, - bool expected_allow_p2p_for_sharing, - const string& expected_p2p_url) { +void OmahaRequestActionTest::P2PTest(bool initial_allow_p2p_for_downloading, + bool initial_allow_p2p_for_sharing, + bool omaha_disable_p2p_for_downloading, + bool omaha_disable_p2p_for_sharing, + bool payload_state_allow_p2p_attempt, + bool expect_p2p_client_lookup, + const string& p2p_client_result_url, + bool expected_allow_p2p_for_downloading, + bool expected_allow_p2p_for_sharing, + const string& expected_p2p_url) { OmahaResponse response; bool actual_allow_p2p_for_downloading = initial_allow_p2p_for_downloading; bool actual_allow_p2p_for_sharing = initial_allow_p2p_for_sharing; @@ -2694,8 +2683,7 @@ void OmahaRequestActionTest::P2PTest( EXPECT_EQ(omaha_disable_p2p_for_downloading, response.disable_p2p_for_downloading); - EXPECT_EQ(omaha_disable_p2p_for_sharing, - response.disable_p2p_for_sharing); + EXPECT_EQ(omaha_disable_p2p_for_sharing, response.disable_p2p_for_sharing); EXPECT_EQ(expected_allow_p2p_for_downloading, actual_allow_p2p_for_downloading); @@ -2717,42 +2705,42 @@ TEST_F(OmahaRequestActionTest, P2PWithPeer) { } TEST_F(OmahaRequestActionTest, P2PWithoutPeer) { - P2PTest(true, // initial_allow_p2p_for_downloading - true, // initial_allow_p2p_for_sharing - false, // omaha_disable_p2p_for_downloading - false, // omaha_disable_p2p_for_sharing - true, // payload_state_allow_p2p_attempt - true, // expect_p2p_client_lookup - "", // p2p_client_result_url - false, // expected_allow_p2p_for_downloading - true, // expected_allow_p2p_for_sharing - ""); // expected_p2p_url + P2PTest(true, // initial_allow_p2p_for_downloading + true, // initial_allow_p2p_for_sharing + false, // omaha_disable_p2p_for_downloading + false, // omaha_disable_p2p_for_sharing + true, // payload_state_allow_p2p_attempt + true, // expect_p2p_client_lookup + "", // p2p_client_result_url + false, // expected_allow_p2p_for_downloading + true, // expected_allow_p2p_for_sharing + ""); // expected_p2p_url } TEST_F(OmahaRequestActionTest, P2PDownloadNotAllowed) { - P2PTest(false, // initial_allow_p2p_for_downloading - true, // initial_allow_p2p_for_sharing - false, // omaha_disable_p2p_for_downloading - false, // omaha_disable_p2p_for_sharing - true, // payload_state_allow_p2p_attempt - false, // expect_p2p_client_lookup - "unset", // p2p_client_result_url - false, // expected_allow_p2p_for_downloading - true, // expected_allow_p2p_for_sharing - ""); // expected_p2p_url + P2PTest(false, // initial_allow_p2p_for_downloading + true, // initial_allow_p2p_for_sharing + false, // omaha_disable_p2p_for_downloading + false, // omaha_disable_p2p_for_sharing + true, // payload_state_allow_p2p_attempt + false, // expect_p2p_client_lookup + "unset", // p2p_client_result_url + false, // expected_allow_p2p_for_downloading + true, // expected_allow_p2p_for_sharing + ""); // expected_p2p_url } TEST_F(OmahaRequestActionTest, P2PWithPeerDownloadDisabledByOmaha) { - P2PTest(true, // initial_allow_p2p_for_downloading - true, // initial_allow_p2p_for_sharing - true, // omaha_disable_p2p_for_downloading - false, // omaha_disable_p2p_for_sharing - true, // payload_state_allow_p2p_attempt - false, // expect_p2p_client_lookup - "unset", // p2p_client_result_url - false, // expected_allow_p2p_for_downloading - true, // expected_allow_p2p_for_sharing - ""); // expected_p2p_url + P2PTest(true, // initial_allow_p2p_for_downloading + true, // initial_allow_p2p_for_sharing + true, // omaha_disable_p2p_for_downloading + false, // omaha_disable_p2p_for_sharing + true, // payload_state_allow_p2p_attempt + false, // expect_p2p_client_lookup + "unset", // p2p_client_result_url + false, // expected_allow_p2p_for_downloading + true, // expected_allow_p2p_for_sharing + ""); // expected_p2p_url } TEST_F(OmahaRequestActionTest, P2PWithPeerSharingDisabledByOmaha) { @@ -2769,20 +2757,20 @@ TEST_F(OmahaRequestActionTest, P2PWithPeerSharingDisabledByOmaha) { } TEST_F(OmahaRequestActionTest, P2PWithPeerBothDisabledByOmaha) { - P2PTest(true, // initial_allow_p2p_for_downloading - true, // initial_allow_p2p_for_sharing - true, // omaha_disable_p2p_for_downloading - true, // omaha_disable_p2p_for_sharing - true, // payload_state_allow_p2p_attempt - false, // expect_p2p_client_lookup - "unset", // p2p_client_result_url - false, // expected_allow_p2p_for_downloading - false, // expected_allow_p2p_for_sharing - ""); // expected_p2p_url -} - -bool OmahaRequestActionTest::InstallDateParseHelper(const string &elapsed_days, - OmahaResponse *response) { + P2PTest(true, // initial_allow_p2p_for_downloading + true, // initial_allow_p2p_for_sharing + true, // omaha_disable_p2p_for_downloading + true, // omaha_disable_p2p_for_sharing + true, // payload_state_allow_p2p_attempt + false, // expect_p2p_client_lookup + "unset", // p2p_client_result_url + false, // expected_allow_p2p_for_downloading + false, // expected_allow_p2p_for_sharing + ""); // expected_p2p_url +} + +bool OmahaRequestActionTest::InstallDateParseHelper(const string& elapsed_days, + OmahaResponse* response) { fake_update_response_.elapsed_days = elapsed_days; return TestUpdateCheck(fake_update_response_.GetUpdateResponse(), -1, diff --git a/omaha_request_params.cc b/omaha_request_params.cc index c4584241..8c410f17 100644 --- a/omaha_request_params.cc +++ b/omaha_request_params.cc @@ -101,8 +101,8 @@ bool OmahaRequestParams::Init(const string& in_app_version, // know (i.e. stat() returns some unexpected error), then err on the side of // caution and say deltas are not okay. struct stat stbuf; - delta_okay_ = (stat((root_ + "/.nodelta").c_str(), &stbuf) < 0) && - (errno == ENOENT); + delta_okay_ = + (stat((root_ + "/.nodelta").c_str(), &stbuf) < 0) && (errno == ENOENT); } else { LOG(INFO) << "Disabling deltas as a channel change to " << mutable_image_props_.target_channel diff --git a/omaha_request_params.h b/omaha_request_params.h index 1bfa4717..18235c04 100644 --- a/omaha_request_params.h +++ b/omaha_request_params.h @@ -306,11 +306,11 @@ class OmahaRequestParams { // changed and cancel the current download attempt. std::string download_channel_; - std::string hwid_; // Hardware Qualification ID of the client + std::string hwid_; // Hardware Qualification ID of the client std::string fw_version_; // Chrome OS Firmware Version. std::string ec_version_; // Chrome OS EC Version. - bool delta_okay_; // If this client can accept a delta - bool interactive_; // Whether this is a user-initiated update check + bool delta_okay_; // If this client can accept a delta + bool interactive_; // Whether this is a user-initiated update check // The URL to send the Omaha request to. std::string update_url_; diff --git a/omaha_response_handler_action.h b/omaha_response_handler_action.h index 344fc1da..d2e6db86 100644 --- a/omaha_response_handler_action.h +++ b/omaha_response_handler_action.h @@ -33,7 +33,7 @@ namespace chromeos_update_engine { class OmahaResponseHandlerAction; -template<> +template <> class ActionTraits<OmahaResponseHandlerAction> { public: typedef OmahaResponse InputObjectType; diff --git a/omaha_response_handler_action_unittest.cc b/omaha_response_handler_action_unittest.cc index b128b279..b47040b6 100644 --- a/omaha_response_handler_action_unittest.cc +++ b/omaha_response_handler_action_unittest.cc @@ -80,14 +80,10 @@ class OmahaResponseHandlerActionTest : public ::testing::Test { protected: void SetUp() override { FakeBootControl* fake_boot_control = fake_system_state_.fake_boot_control(); - fake_boot_control->SetPartitionDevice( - kPartitionNameKernel, 0, "/dev/sdz2"); - fake_boot_control->SetPartitionDevice( - kPartitionNameRoot, 0, "/dev/sdz3"); - fake_boot_control->SetPartitionDevice( - kPartitionNameKernel, 1, "/dev/sdz4"); - fake_boot_control->SetPartitionDevice( - kPartitionNameRoot, 1, "/dev/sdz5"); + fake_boot_control->SetPartitionDevice(kPartitionNameKernel, 0, "/dev/sdz2"); + fake_boot_control->SetPartitionDevice(kPartitionNameRoot, 0, "/dev/sdz3"); + fake_boot_control->SetPartitionDevice(kPartitionNameKernel, 1, "/dev/sdz4"); + fake_boot_control->SetPartitionDevice(kPartitionNameRoot, 1, "/dev/sdz5"); } // Return true iff the OmahaResponseHandlerAction succeeded. diff --git a/p2p_manager.cc b/p2p_manager.cc index 1ee124dc..67209086 100644 --- a/p2p_manager.cc +++ b/p2p_manager.cc @@ -89,9 +89,7 @@ class ConfigurationImpl : public P2PManager::Configuration { public: ConfigurationImpl() {} - FilePath GetP2PDir() override { - return FilePath(kDefaultP2PDir); - } + FilePath GetP2PDir() override { return FilePath(kDefaultP2PDir); } vector<string> GetInitctlArgs(bool is_start) override { vector<string> args; @@ -101,7 +99,7 @@ class ConfigurationImpl : public P2PManager::Configuration { return args; } - vector<string> GetP2PClientArgs(const string &file_id, + vector<string> GetP2PClientArgs(const string& file_id, size_t minimum_size) override { vector<string> args; args.push_back("p2p-client"); @@ -117,8 +115,8 @@ class ConfigurationImpl : public P2PManager::Configuration { // The default P2PManager implementation. class P2PManagerImpl : public P2PManager { public: - P2PManagerImpl(Configuration *configuration, - ClockInterface *clock, + P2PManagerImpl(Configuration* configuration, + ClockInterface* clock, UpdateManager* update_manager, const string& file_extension, const int num_files_to_keep, @@ -134,22 +132,17 @@ class P2PManagerImpl : public P2PManager { size_t minimum_size, TimeDelta max_time_to_wait, LookupCallback callback) override; - bool FileShare(const string& file_id, - size_t expected_size) override; + bool FileShare(const string& file_id, size_t expected_size) override; FilePath FileGetPath(const string& file_id) override; ssize_t FileGetSize(const string& file_id) override; ssize_t FileGetExpectedSize(const string& file_id) override; - bool FileGetVisible(const string& file_id, - bool *out_result) override; + bool FileGetVisible(const string& file_id, bool* out_result) override; bool FileMakeVisible(const string& file_id) override; int CountSharedFiles() override; private: // Enumeration for specifying visibility. - enum Visibility { - kVisible, - kNonVisible - }; + enum Visibility { kVisible, kNonVisible }; // Returns "." + |file_extension_| + ".p2p" if |visibility| is // |kVisible|. Returns the same concatenated with ".tmp" otherwise. @@ -218,19 +211,19 @@ const char P2PManagerImpl::kP2PExtension[] = ".p2p"; const char P2PManagerImpl::kTmpExtension[] = ".tmp"; -P2PManagerImpl::P2PManagerImpl(Configuration *configuration, - ClockInterface *clock, +P2PManagerImpl::P2PManagerImpl(Configuration* configuration, + ClockInterface* clock, UpdateManager* update_manager, const string& file_extension, const int num_files_to_keep, const TimeDelta& max_file_age) - : clock_(clock), - update_manager_(update_manager), - file_extension_(file_extension), - num_files_to_keep_(num_files_to_keep), - max_file_age_(max_file_age) { - configuration_.reset(configuration != nullptr ? configuration : - new ConfigurationImpl()); + : clock_(clock), + update_manager_(update_manager), + file_extension_(file_extension), + num_files_to_keep_(num_files_to_keep), + max_file_age_(max_file_age) { + configuration_.reset(configuration != nullptr ? configuration + : new ConfigurationImpl()); } void P2PManagerImpl::SetDevicePolicy( @@ -272,9 +265,9 @@ bool P2PManagerImpl::EnsureP2P(bool should_be_running) { // running" or "stop if running". // TODO(zeuthen,chromium:277051): Avoid doing this. if (return_code != 0) { - const char *expected_error_message = should_be_running ? - "initctl: Job is already running: p2p\n" : - "initctl: Unknown instance \n"; + const char* expected_error_message = + should_be_running ? "initctl: Job is already running: p2p\n" + : "initctl: Unknown instance \n"; if (output != expected_error_message) return false; } @@ -303,13 +296,13 @@ static bool MatchCompareFunc(const pair<FilePath, Time>& a, string P2PManagerImpl::GetExt(Visibility visibility) { string ext = string(".") + file_extension_ + kP2PExtension; switch (visibility) { - case kVisible: - break; - case kNonVisible: - ext += kTmpExtension; - break; - // Don't add a default case to let the compiler warn about newly - // added enum values. + case kVisible: + break; + case kNonVisible: + ext += kTmpExtension; + break; + // Don't add a default case to let the compiler warn about newly + // added enum values. } return ext; } @@ -318,10 +311,9 @@ FilePath P2PManagerImpl::GetPath(const string& file_id, Visibility visibility) { return configuration_->GetP2PDir().Append(file_id + GetExt(visibility)); } -bool P2PManagerImpl::DeleteP2PFile(const FilePath& path, - const string& reason) { - LOG(INFO) << "Deleting p2p file " << path.value() - << " (reason: " << reason << ")"; +bool P2PManagerImpl::DeleteP2PFile(const FilePath& path, const string& reason) { + LOG(INFO) << "Deleting p2p file " << path.value() << " (reason: " << reason + << ")"; if (unlink(path.value().c_str()) != 0) { PLOG(ERROR) << "Error deleting p2p file " << path.value(); return false; @@ -329,7 +321,6 @@ bool P2PManagerImpl::DeleteP2PFile(const FilePath& path, return true; } - bool P2PManagerImpl::PerformHousekeeping() { // Open p2p dir. FilePath p2p_dir = configuration_->GetP2PDir(); @@ -342,10 +333,10 @@ bool P2PManagerImpl::PerformHousekeeping() { base::FileEnumerator dir(p2p_dir, false, base::FileEnumerator::FILES); // Go through all files and collect their mtime. for (FilePath name = dir.Next(); !name.empty(); name = dir.Next()) { - if (!(base::EndsWith(name.value(), ext_visible, - base::CompareCase::SENSITIVE) || - base::EndsWith(name.value(), ext_non_visible, - base::CompareCase::SENSITIVE))) { + if (!(base::EndsWith( + name.value(), ext_visible, base::CompareCase::SENSITIVE) || + base::EndsWith( + name.value(), ext_non_visible, base::CompareCase::SENSITIVE))) { continue; } @@ -382,7 +373,7 @@ bool P2PManagerImpl::PerformHousekeeping() { class LookupData { public: explicit LookupData(P2PManager::LookupCallback callback) - : callback_(callback) {} + : callback_(callback) {} ~LookupData() { if (timeout_task_ != MessageLoop::kTaskIdNull) @@ -399,7 +390,9 @@ class LookupData { // We expect to run just "p2p-client" and find it in the path. child_pid_ = Subprocess::Get().ExecFlags( - cmd, Subprocess::kSearchPath, {}, + cmd, + Subprocess::kSearchPath, + {}, Bind(&LookupData::OnLookupDone, base::Unretained(this))); if (!child_pid_) { @@ -418,9 +411,10 @@ class LookupData { private: void ReportErrorAndDeleteInIdle() { - MessageLoop::current()->PostTask(FROM_HERE, Bind( - &LookupData::OnIdleForReportErrorAndDelete, - base::Unretained(this))); + MessageLoop::current()->PostTask( + FROM_HERE, + Bind(&LookupData::OnIdleForReportErrorAndDelete, + base::Unretained(this))); } void OnIdleForReportErrorAndDelete() { @@ -463,8 +457,7 @@ class LookupData { void OnLookupDone(int return_code, const string& output) { child_pid_ = 0; if (return_code != 0) { - LOG(INFO) << "Child exited with non-zero exit code " - << return_code; + LOG(INFO) << "Child exited with non-zero exit code " << return_code; ReportError(); } else { ReportSuccess(output); @@ -494,15 +487,14 @@ void P2PManagerImpl::LookupUrlForFile(const string& file_id, size_t minimum_size, TimeDelta max_time_to_wait, LookupCallback callback) { - LookupData *lookup_data = new LookupData(callback); + LookupData* lookup_data = new LookupData(callback); string file_id_with_ext = file_id + "." + file_extension_; - vector<string> args = configuration_->GetP2PClientArgs(file_id_with_ext, - minimum_size); + vector<string> args = + configuration_->GetP2PClientArgs(file_id_with_ext, minimum_size); lookup_data->InitiateLookup(args, max_time_to_wait); } -bool P2PManagerImpl::FileShare(const string& file_id, - size_t expected_size) { +bool P2PManagerImpl::FileShare(const string& file_id, size_t expected_size) { // Check if file already exist. FilePath path = FileGetPath(file_id); if (!path.empty()) { @@ -563,8 +555,8 @@ bool P2PManagerImpl::FileShare(const string& file_id, } else { // ENOSPC can happen (funky race though, cf. the statvfs() check // above), handle it gracefully, e.g. use logging level INFO. - PLOG(INFO) << "Error allocating " << expected_size - << " bytes for file " << path.value(); + PLOG(INFO) << "Error allocating " << expected_size << " bytes for file " + << path.value(); if (unlink(path.value().c_str()) != 0) { PLOG(ERROR) << "Error deleting file with path " << path.value(); } @@ -573,8 +565,11 @@ bool P2PManagerImpl::FileShare(const string& file_id, } string decimal_size = std::to_string(expected_size); - if (fsetxattr(fd, kCrosP2PFileSizeXAttrName, - decimal_size.c_str(), decimal_size.size(), 0) != 0) { + if (fsetxattr(fd, + kCrosP2PFileSizeXAttrName, + decimal_size.c_str(), + decimal_size.size(), + 0) != 0) { PLOG(ERROR) << "Error setting xattr " << path.value(); return false; } @@ -601,8 +596,7 @@ FilePath P2PManagerImpl::FileGetPath(const string& file_id) { return path; } -bool P2PManagerImpl::FileGetVisible(const string& file_id, - bool *out_result) { +bool P2PManagerImpl::FileGetVisible(const string& file_id, bool* out_result) { FilePath path = FileGetPath(file_id); if (path.empty()) { LOG(ERROR) << "No file for id " << file_id; @@ -628,8 +622,8 @@ bool P2PManagerImpl::FileMakeVisible(const string& file_id) { FilePath new_path = path.RemoveExtension(); LOG_ASSERT(new_path.MatchesExtension(kP2PExtension)); if (rename(path.value().c_str(), new_path.value().c_str()) != 0) { - PLOG(ERROR) << "Error renaming " << path.value() - << " to " << new_path.value(); + PLOG(ERROR) << "Error renaming " << path.value() << " to " + << new_path.value(); return false; } @@ -649,10 +643,12 @@ ssize_t P2PManagerImpl::FileGetExpectedSize(const string& file_id) { if (path.empty()) return -1; - char ea_value[64] = { 0 }; + char ea_value[64] = {0}; ssize_t ea_size; - ea_size = getxattr(path.value().c_str(), kCrosP2PFileSizeXAttrName, - &ea_value, sizeof(ea_value) - 1); + ea_size = getxattr(path.value().c_str(), + kCrosP2PFileSizeXAttrName, + &ea_value, + sizeof(ea_value) - 1); if (ea_size == -1) { PLOG(ERROR) << "Error calling getxattr() on file " << path.value(); return -1; @@ -661,9 +657,8 @@ ssize_t P2PManagerImpl::FileGetExpectedSize(const string& file_id) { char* endp = nullptr; long long int val = strtoll(ea_value, &endp, 0); // NOLINT(runtime/int) if (*endp != '\0') { - LOG(ERROR) << "Error parsing the value '" << ea_value - << "' of the xattr " << kCrosP2PFileSizeXAttrName - << " as an integer"; + LOG(ERROR) << "Error parsing the value '" << ea_value << "' of the xattr " + << kCrosP2PFileSizeXAttrName << " as an integer"; return -1; } @@ -679,10 +674,10 @@ int P2PManagerImpl::CountSharedFiles() { base::FileEnumerator dir(p2p_dir, false, base::FileEnumerator::FILES); for (FilePath name = dir.Next(); !name.empty(); name = dir.Next()) { - if (base::EndsWith(name.value(), ext_visible, - base::CompareCase::SENSITIVE) || - base::EndsWith(name.value(), ext_non_visible, - base::CompareCase::SENSITIVE)) { + if (base::EndsWith( + name.value(), ext_visible, base::CompareCase::SENSITIVE) || + base::EndsWith( + name.value(), ext_non_visible, base::CompareCase::SENSITIVE)) { num_files += 1; } } @@ -694,10 +689,10 @@ void P2PManagerImpl::ScheduleEnabledStatusChange() { if (waiting_for_enabled_status_change_) return; - Callback<void(EvalStatus, const bool&)> callback = Bind( - &P2PManagerImpl::OnEnabledStatusChange, base::Unretained(this)); - update_manager_->AsyncPolicyRequest(callback, &Policy::P2PEnabledChanged, - is_enabled_); + Callback<void(EvalStatus, const bool&)> callback = + Bind(&P2PManagerImpl::OnEnabledStatusChange, base::Unretained(this)); + update_manager_->AsyncPolicyRequest( + callback, &Policy::P2PEnabledChanged, is_enabled_); waiting_for_enabled_status_change_ = true; } @@ -727,13 +722,12 @@ void P2PManagerImpl::OnEnabledStatusChange(EvalStatus status, ScheduleEnabledStatusChange(); } -P2PManager* P2PManager::Construct( - Configuration *configuration, - ClockInterface *clock, - UpdateManager* update_manager, - const string& file_extension, - const int num_files_to_keep, - const TimeDelta& max_file_age) { +P2PManager* P2PManager::Construct(Configuration* configuration, + ClockInterface* clock, + UpdateManager* update_manager, + const string& file_extension, + const int num_files_to_keep, + const TimeDelta& max_file_age) { return new P2PManagerImpl(configuration, clock, update_manager, diff --git a/p2p_manager.h b/p2p_manager.h index 4ffab9ad..ef62f0df 100644 --- a/p2p_manager.h +++ b/p2p_manager.h @@ -119,8 +119,7 @@ class P2PManager { // // If the file already exists, true is returned. Any on-disk xattr // is not updated. - virtual bool FileShare(const std::string& file_id, - size_t expected_size) = 0; + virtual bool FileShare(const std::string& file_id, size_t expected_size) = 0; // Gets a fully qualified path for the file identified by |file_id|. // If the file has not been shared already using the FileShare() @@ -148,8 +147,7 @@ class P2PManager { // Gets whether the file identified by |file_id| is publicly // visible. If |out_result| is not null, the result is returned // there. Returns false if an error occurs. - virtual bool FileGetVisible(const std::string& file_id, - bool *out_result) = 0; + virtual bool FileGetVisible(const std::string& file_id, bool* out_result) = 0; // Makes the file identified by |file_id| publicly visible // (e.g. removes the .tmp extension). If the file is already @@ -175,8 +173,8 @@ class P2PManager { // |max_file_age| parameter specifies the maximum file age after // performing housekeeping (pass zero to allow files of any age). static P2PManager* Construct( - Configuration *configuration, - ClockInterface *clock, + Configuration* configuration, + ClockInterface* clock, chromeos_update_manager::UpdateManager* update_manager, const std::string& file_extension, const int num_files_to_keep, diff --git a/p2p_manager_unittest.cc b/p2p_manager_unittest.cc index 736a87a7..5771ec1d 100644 --- a/p2p_manager_unittest.cc +++ b/p2p_manager_unittest.cc @@ -55,10 +55,10 @@ using brillo::MessageLoop; using std::string; using std::unique_ptr; using std::vector; +using testing::_; using testing::DoAll; using testing::Return; using testing::SetArgPointee; -using testing::_; namespace chromeos_update_engine { @@ -84,8 +84,11 @@ class P2PManagerTest : public testing::Test { fake_um_.set_policy(mock_policy_); // Construct the P2P manager under test. - manager_.reset(P2PManager::Construct(test_conf_, &fake_clock_, &fake_um_, - "cros_au", 3, + manager_.reset(P2PManager::Construct(test_conf_, + &fake_clock_, + &fake_um_, + "cros_au", + 3, TimeDelta::FromDays(5))); } @@ -95,16 +98,15 @@ class P2PManagerTest : public testing::Test { Subprocess subprocess_; // The P2PManager::Configuration instance used for testing. - FakeP2PManagerConfiguration *test_conf_; + FakeP2PManagerConfiguration* test_conf_; FakeClock fake_clock_; - chromeos_update_manager::MockPolicy *mock_policy_ = nullptr; + chromeos_update_manager::MockPolicy* mock_policy_ = nullptr; chromeos_update_manager::FakeUpdateManager fake_um_; unique_ptr<P2PManager> manager_; }; - // Check that IsP2PEnabled() polls the policy correctly, with the value not // changing between calls. TEST_F(P2PManagerTest, P2PEnabledInitAndNotChanged) { @@ -120,9 +122,8 @@ TEST_F(P2PManagerTest, P2PEnabledInitAndNotChanged) { // between calls. TEST_F(P2PManagerTest, P2PEnabledInitAndChanged) { EXPECT_CALL(*mock_policy_, P2PEnabled(_, _, _, _)) - .WillOnce(DoAll( - SetArgPointee<3>(true), - Return(chromeos_update_manager::EvalStatus::kSucceeded))); + .WillOnce(DoAll(SetArgPointee<3>(true), + Return(chromeos_update_manager::EvalStatus::kSucceeded))); EXPECT_CALL(*mock_policy_, P2PEnabledChanged(_, _, _, _, true)); EXPECT_CALL(*mock_policy_, P2PEnabledChanged(_, _, _, _, false)); @@ -137,23 +138,26 @@ TEST_F(P2PManagerTest, HousekeepingCountLimit) { // we need to reallocate the test_conf_ member, whose currently aliased object // will be freed. test_conf_ = new FakeP2PManagerConfiguration(); - manager_.reset(P2PManager::Construct( - test_conf_, &fake_clock_, &fake_um_, "cros_au", 3, - TimeDelta() /* max_file_age */)); + manager_.reset(P2PManager::Construct(test_conf_, + &fake_clock_, + &fake_um_, + "cros_au", + 3, + TimeDelta() /* max_file_age */)); EXPECT_EQ(manager_->CountSharedFiles(), 0); base::Time start_time = base::Time::FromDoubleT(1246996800.); // Generate files with different timestamps matching our pattern and generate // other files not matching the pattern. for (int n = 0; n < 5; n++) { - base::FilePath path = test_conf_->GetP2PDir().Append(base::StringPrintf( - "file_%d.cros_au.p2p", n)); + base::FilePath path = test_conf_->GetP2PDir().Append( + base::StringPrintf("file_%d.cros_au.p2p", n)); base::Time file_time = start_time + TimeDelta::FromMinutes(n); EXPECT_EQ(0, base::WriteFile(path, nullptr, 0)); EXPECT_TRUE(base::TouchFile(path, file_time, file_time)); - path = test_conf_->GetP2PDir().Append(base::StringPrintf( - "file_%d.OTHER.p2p", n)); + path = test_conf_->GetP2PDir().Append( + base::StringPrintf("file_%d.OTHER.p2p", n)); EXPECT_EQ(0, base::WriteFile(path, nullptr, 0)); EXPECT_TRUE(base::TouchFile(path, file_time, file_time)); } @@ -170,13 +174,11 @@ TEST_F(P2PManagerTest, HousekeepingCountLimit) { expect = (n >= 2); file_name = base::StringPrintf( - "%s/file_%d.cros_au.p2p", - test_conf_->GetP2PDir().value().c_str(), n); + "%s/file_%d.cros_au.p2p", test_conf_->GetP2PDir().value().c_str(), n); EXPECT_EQ(expect, utils::FileExists(file_name.c_str())); file_name = base::StringPrintf( - "%s/file_%d.OTHER.p2p", - test_conf_->GetP2PDir().value().c_str(), n); + "%s/file_%d.OTHER.p2p", test_conf_->GetP2PDir().value().c_str(), n); EXPECT_TRUE(utils::FileExists(file_name.c_str())); } // CountSharedFiles() only counts 'cros_au' files. @@ -201,16 +203,19 @@ TEST_F(P2PManagerTest, HousekeepingAgeLimit) { // Note that we need to reallocate the test_conf_ member, whose currently // aliased object will be freed. test_conf_ = new FakeP2PManagerConfiguration(); - manager_.reset(P2PManager::Construct( - test_conf_, &fake_clock_, &fake_um_, "cros_au", - 0 /* num_files_to_keep */, age_limit)); + manager_.reset(P2PManager::Construct(test_conf_, + &fake_clock_, + &fake_um_, + "cros_au", + 0 /* num_files_to_keep */, + age_limit)); EXPECT_EQ(manager_->CountSharedFiles(), 0); // Generate files with different timestamps matching our pattern and generate // other files not matching the pattern. for (int n = 0; n < 5; n++) { - base::FilePath path = test_conf_->GetP2PDir().Append(base::StringPrintf( - "file_%d.cros_au.p2p", n)); + base::FilePath path = test_conf_->GetP2PDir().Append( + base::StringPrintf("file_%d.cros_au.p2p", n)); // With five files and aiming for two of them to be before // |cutoff_time|, we distribute it like this: @@ -219,14 +224,14 @@ TEST_F(P2PManagerTest, HousekeepingAgeLimit) { // | // cutoff_time // - base::Time file_date = cutoff_time + (n - 2) * TimeDelta::FromDays(1) - + TimeDelta::FromHours(12); + base::Time file_date = cutoff_time + (n - 2) * TimeDelta::FromDays(1) + + TimeDelta::FromHours(12); EXPECT_EQ(0, base::WriteFile(path, nullptr, 0)); EXPECT_TRUE(base::TouchFile(path, file_date, file_date)); - path = test_conf_->GetP2PDir().Append(base::StringPrintf( - "file_%d.OTHER.p2p", n)); + path = test_conf_->GetP2PDir().Append( + base::StringPrintf("file_%d.OTHER.p2p", n)); EXPECT_EQ(0, base::WriteFile(path, nullptr, 0)); EXPECT_TRUE(base::TouchFile(path, file_date, file_date)); } @@ -243,23 +248,23 @@ TEST_F(P2PManagerTest, HousekeepingAgeLimit) { expect = (n >= 2); file_name = base::StringPrintf( - "%s/file_%d.cros_au.p2p", - test_conf_->GetP2PDir().value().c_str(), n); + "%s/file_%d.cros_au.p2p", test_conf_->GetP2PDir().value().c_str(), n); EXPECT_EQ(expect, utils::FileExists(file_name.c_str())); file_name = base::StringPrintf( - "%s/file_%d.OTHER.p2p", - test_conf_->GetP2PDir().value().c_str(), n); + "%s/file_%d.OTHER.p2p", test_conf_->GetP2PDir().value().c_str(), n); EXPECT_TRUE(utils::FileExists(file_name.c_str())); } // CountSharedFiles() only counts 'cros_au' files. EXPECT_EQ(manager_->CountSharedFiles(), 3); } -static bool CheckP2PFile(const string& p2p_dir, const string& file_name, - ssize_t expected_size, ssize_t expected_size_xattr) { +static bool CheckP2PFile(const string& p2p_dir, + const string& file_name, + ssize_t expected_size, + ssize_t expected_size_xattr) { string path = p2p_dir + "/" + file_name; - char ea_value[64] = { 0 }; + char ea_value[64] = {0}; ssize_t ea_size; off_t p2p_size = utils::FileSize(path); @@ -270,15 +275,15 @@ static bool CheckP2PFile(const string& p2p_dir, const string& file_name, if (expected_size != 0) { if (p2p_size != expected_size) { - LOG(ERROR) << "Expected size " << expected_size - << " but size was " << p2p_size; + LOG(ERROR) << "Expected size " << expected_size << " but size was " + << p2p_size; return false; } } if (expected_size_xattr == 0) { - ea_size = getxattr(path.c_str(), "user.cros-p2p-filesize", - &ea_value, sizeof ea_value - 1); + ea_size = getxattr( + path.c_str(), "user.cros-p2p-filesize", &ea_value, sizeof ea_value - 1); if (ea_size == -1 && errno == ENODATA) { // This is valid behavior as we support files without the xattr set. } else { @@ -287,8 +292,8 @@ static bool CheckP2PFile(const string& p2p_dir, const string& file_name, return false; } } else { - ea_size = getxattr(path.c_str(), "user.cros-p2p-filesize", - &ea_value, sizeof ea_value - 1); + ea_size = getxattr( + path.c_str(), "user.cros-p2p-filesize", &ea_value, sizeof ea_value - 1); if (ea_size < 0) { LOG(ERROR) << "Error getting xattr attribute"; return false; @@ -296,8 +301,7 @@ static bool CheckP2PFile(const string& p2p_dir, const string& file_name, char* endp = nullptr; long long int val = strtoll(ea_value, &endp, 0); // NOLINT(runtime/int) if (endp == nullptr || *endp != '\0') { - LOG(ERROR) << "Error parsing xattr '" << ea_value - << "' as an integer"; + LOG(ERROR) << "Error parsing xattr '" << ea_value << "' as an integer"; return false; } if (val != expected_size_xattr) { @@ -310,11 +314,13 @@ static bool CheckP2PFile(const string& p2p_dir, const string& file_name, return true; } -static bool CreateP2PFile(string p2p_dir, string file_name, - size_t size, size_t size_xattr) { +static bool CreateP2PFile(string p2p_dir, + string file_name, + size_t size, + size_t size_xattr) { string path = p2p_dir + "/" + file_name; - int fd = open(path.c_str(), O_CREAT|O_RDWR, 0644); + int fd = open(path.c_str(), O_CREAT | O_RDWR, 0644); if (fd == -1) { PLOG(ERROR) << "Error creating file with path " << path; return false; @@ -327,8 +333,11 @@ static bool CreateP2PFile(string p2p_dir, string file_name, if (size_xattr != 0) { string decimal_size = std::to_string(size_xattr); - if (fsetxattr(fd, "user.cros-p2p-filesize", - decimal_size.c_str(), decimal_size.size(), 0) != 0) { + if (fsetxattr(fd, + "user.cros-p2p-filesize", + decimal_size.c_str(), + decimal_size.size(), + 0) != 0) { PLOG(ERROR) << "Error setting xattr on " << path; close(fd); return false; @@ -347,7 +356,9 @@ TEST_F(P2PManagerTest, ShareFile) { EXPECT_EQ(manager_->FileGetPath("foo"), test_conf_->GetP2PDir().Append("foo.cros_au.p2p.tmp")); EXPECT_TRUE(CheckP2PFile(test_conf_->GetP2PDir().value(), - "foo.cros_au.p2p.tmp", 0, kP2PTestFileSize)); + "foo.cros_au.p2p.tmp", + 0, + kP2PTestFileSize)); // Sharing it again - with the same expected size - should return true EXPECT_TRUE(manager_->FileShare("foo", kP2PTestFileSize)); @@ -365,7 +376,9 @@ TEST_F(P2PManagerTest, MakeFileVisible) { EXPECT_EQ(manager_->FileGetPath("foo"), test_conf_->GetP2PDir().Append("foo.cros_au.p2p.tmp")); EXPECT_TRUE(CheckP2PFile(test_conf_->GetP2PDir().value(), - "foo.cros_au.p2p.tmp", 0, kP2PTestFileSize)); + "foo.cros_au.p2p.tmp", + 0, + kP2PTestFileSize)); // Make the file visible and check that it changed its name. Do it // twice to check that FileMakeVisible() is idempotent. for (int n = 0; n < 2; n++) { @@ -373,7 +386,9 @@ TEST_F(P2PManagerTest, MakeFileVisible) { EXPECT_EQ(manager_->FileGetPath("foo"), test_conf_->GetP2PDir().Append("foo.cros_au.p2p")); EXPECT_TRUE(CheckP2PFile(test_conf_->GetP2PDir().value(), - "foo.cros_au.p2p", 0, kP2PTestFileSize)); + "foo.cros_au.p2p", + 0, + kP2PTestFileSize)); } } @@ -387,8 +402,8 @@ TEST_F(P2PManagerTest, ExistingFiles) { EXPECT_EQ(manager_->FileGetExpectedSize("foo"), -1); EXPECT_FALSE(manager_->FileGetVisible("foo", nullptr)); // ... then create the file ... - EXPECT_TRUE(CreateP2PFile(test_conf_->GetP2PDir().value(), - "foo.cros_au.p2p", 42, 43)); + EXPECT_TRUE(CreateP2PFile( + test_conf_->GetP2PDir().value(), "foo.cros_au.p2p", 42, 43)); // ... and then check that the expected values are returned EXPECT_EQ(manager_->FileGetPath("foo"), test_conf_->GetP2PDir().Append("foo.cros_au.p2p")); @@ -403,8 +418,8 @@ TEST_F(P2PManagerTest, ExistingFiles) { EXPECT_EQ(manager_->FileGetExpectedSize("bar"), -1); EXPECT_FALSE(manager_->FileGetVisible("bar", nullptr)); // ... then create the file ... - EXPECT_TRUE(CreateP2PFile(test_conf_->GetP2PDir().value(), - "bar.cros_au.p2p.tmp", 44, 45)); + EXPECT_TRUE(CreateP2PFile( + test_conf_->GetP2PDir().value(), "bar.cros_au.p2p.tmp", 44, 45)); // ... and then check that the expected values are returned EXPECT_EQ(manager_->FileGetPath("bar"), test_conf_->GetP2PDir().Append("bar.cros_au.p2p.tmp")); @@ -423,11 +438,11 @@ TEST_F(P2PManagerTest, StartP2P) { EXPECT_TRUE(manager_->EnsureP2PRunning()); test_conf_->SetInitctlStartCommand({"false"}); EXPECT_FALSE(manager_->EnsureP2PRunning()); - test_conf_->SetInitctlStartCommand({ - "sh", "-c", "echo \"initctl: Job is already running: p2p\" >&2; false"}); + test_conf_->SetInitctlStartCommand( + {"sh", "-c", "echo \"initctl: Job is already running: p2p\" >&2; false"}); EXPECT_TRUE(manager_->EnsureP2PRunning()); - test_conf_->SetInitctlStartCommand({ - "sh", "-c", "echo something else >&2; false"}); + test_conf_->SetInitctlStartCommand( + {"sh", "-c", "echo something else >&2; false"}); EXPECT_FALSE(manager_->EnsureP2PRunning()); } @@ -438,16 +453,15 @@ TEST_F(P2PManagerTest, StopP2P) { EXPECT_TRUE(manager_->EnsureP2PNotRunning()); test_conf_->SetInitctlStopCommand({"false"}); EXPECT_FALSE(manager_->EnsureP2PNotRunning()); - test_conf_->SetInitctlStopCommand({ - "sh", "-c", "echo \"initctl: Unknown instance \" >&2; false"}); + test_conf_->SetInitctlStopCommand( + {"sh", "-c", "echo \"initctl: Unknown instance \" >&2; false"}); EXPECT_TRUE(manager_->EnsureP2PNotRunning()); - test_conf_->SetInitctlStopCommand({ - "sh", "-c", "echo something else >&2; false"}); + test_conf_->SetInitctlStopCommand( + {"sh", "-c", "echo something else >&2; false"}); EXPECT_FALSE(manager_->EnsureP2PNotRunning()); } -static void ExpectUrl(const string& expected_url, - const string& url) { +static void ExpectUrl(const string& expected_url, const string& url) { EXPECT_EQ(url, expected_url); MessageLoop::current()->BreakLoop(); } @@ -457,53 +471,56 @@ static void ExpectUrl(const string& expected_url, TEST_F(P2PManagerTest, LookupURL) { // Emulate p2p-client returning valid URL with "fooX", 42 and "cros_au" // being propagated in the right places. - test_conf_->SetP2PClientCommand({ - "echo", "http://1.2.3.4/{file_id}_{minsize}"}); - manager_->LookupUrlForFile("fooX", 42, TimeDelta(), - base::Bind(ExpectUrl, - "http://1.2.3.4/fooX.cros_au_42")); + test_conf_->SetP2PClientCommand( + {"echo", "http://1.2.3.4/{file_id}_{minsize}"}); + manager_->LookupUrlForFile( + "fooX", + 42, + TimeDelta(), + base::Bind(ExpectUrl, "http://1.2.3.4/fooX.cros_au_42")); loop_.Run(); // Emulate p2p-client returning invalid URL. test_conf_->SetP2PClientCommand({"echo", "not_a_valid_url"}); - manager_->LookupUrlForFile("foobar", 42, TimeDelta(), - base::Bind(ExpectUrl, "")); + manager_->LookupUrlForFile( + "foobar", 42, TimeDelta(), base::Bind(ExpectUrl, "")); loop_.Run(); // Emulate p2p-client conveying failure. test_conf_->SetP2PClientCommand({"false"}); - manager_->LookupUrlForFile("foobar", 42, TimeDelta(), - base::Bind(ExpectUrl, "")); + manager_->LookupUrlForFile( + "foobar", 42, TimeDelta(), base::Bind(ExpectUrl, "")); loop_.Run(); // Emulate p2p-client not existing. test_conf_->SetP2PClientCommand({"/path/to/non/existent/helper/program"}); - manager_->LookupUrlForFile("foobar", 42, - TimeDelta(), - base::Bind(ExpectUrl, "")); + manager_->LookupUrlForFile( + "foobar", 42, TimeDelta(), base::Bind(ExpectUrl, "")); loop_.Run(); // Emulate p2p-client crashing. test_conf_->SetP2PClientCommand({"sh", "-c", "kill -SEGV $$"}); - manager_->LookupUrlForFile("foobar", 42, TimeDelta(), - base::Bind(ExpectUrl, "")); + manager_->LookupUrlForFile( + "foobar", 42, TimeDelta(), base::Bind(ExpectUrl, "")); loop_.Run(); // Emulate p2p-client exceeding its timeout. - test_conf_->SetP2PClientCommand({ - "sh", "-c", - // The 'sleep' launched below could be left behind as an orphaned - // process when the 'sh' process is terminated by SIGTERM. As a - // remedy, trap SIGTERM and kill the 'sleep' process, which requires - // launching 'sleep' in background and then waiting for it. - "cleanup() { kill \"${sleep_pid}\"; exit 0; }; " - "trap cleanup TERM; " - "sleep 5 & " - "sleep_pid=$!; " - "echo http://1.2.3.4/; " - "wait" - }); - manager_->LookupUrlForFile("foobar", 42, TimeDelta::FromMilliseconds(500), + test_conf_->SetP2PClientCommand( + {"sh", + "-c", + // The 'sleep' launched below could be left behind as an orphaned + // process when the 'sh' process is terminated by SIGTERM. As a + // remedy, trap SIGTERM and kill the 'sleep' process, which requires + // launching 'sleep' in background and then waiting for it. + "cleanup() { kill \"${sleep_pid}\"; exit 0; }; " + "trap cleanup TERM; " + "sleep 5 & " + "sleep_pid=$!; " + "echo http://1.2.3.4/; " + "wait"}); + manager_->LookupUrlForFile("foobar", + 42, + TimeDelta::FromMilliseconds(500), base::Bind(ExpectUrl, "")); loop_.Run(); } diff --git a/parcelable_update_engine_status_unittest.cc b/parcelable_update_engine_status_unittest.cc index f4bd5183..20decb6b 100644 --- a/parcelable_update_engine_status_unittest.cc +++ b/parcelable_update_engine_status_unittest.cc @@ -21,9 +21,9 @@ #include <gtest/gtest.h> using android::Parcel; +using android::status_t; using android::String16; using android::brillo::ParcelableUpdateEngineStatus; -using android::status_t; using update_engine::UpdateEngineStatus; using update_engine::UpdateStatus; diff --git a/payload_state.cc b/payload_state.cc index ab7912ee..a6c36201 100644 --- a/payload_state.cc +++ b/payload_state.cc @@ -193,7 +193,7 @@ void PayloadState::AttemptStarted(AttemptType attempt_type) { attempt_type_ = attempt_type; - ClockInterface *clock = system_state_->clock(); + ClockInterface* clock = system_state_->clock(); attempt_start_time_boot_ = clock->GetBootTime(); attempt_start_time_monotonic_ = clock->GetMonotonicTime(); attempt_num_bytes_downloaded_ = 0; @@ -257,8 +257,8 @@ void PayloadState::UpdateSucceeded() { void PayloadState::UpdateFailed(ErrorCode error) { ErrorCode base_error = utils::GetBaseErrorCode(error); - LOG(INFO) << "Updating payload state for error code: " << base_error - << " (" << utils::ErrorCodeToString(base_error) << ")"; + LOG(INFO) << "Updating payload state for error code: " << base_error << " (" + << utils::ErrorCodeToString(base_error) << ")"; if (candidate_urls_.size() == 0) { // This means we got this error even before we got a valid Omaha response @@ -280,7 +280,6 @@ void PayloadState::UpdateFailed(ErrorCode error) { break; } - switch (base_error) { // Errors which are good indicators of a problem with a particular URL or // the protocol used in the URL or entities in the communication channel @@ -312,14 +311,14 @@ void PayloadState::UpdateFailed(ErrorCode error) { IncrementUrlIndex(); break; - // Errors which seem to be just transient network/communication related - // failures and do not indicate any inherent problem with the URL itself. - // So, we should keep the current URL but just increment the - // failure count to give it more chances. This way, while we maximize our - // chances of downloading from the URLs that appear earlier in the response - // (because download from a local server URL that appears earlier in a - // response is preferable than downloading from the next URL which could be - // a internet URL and thus could be more expensive). + // Errors which seem to be just transient network/communication related + // failures and do not indicate any inherent problem with the URL itself. + // So, we should keep the current URL but just increment the + // failure count to give it more chances. This way, while we maximize our + // chances of downloading from the URLs that appear earlier in the + // response (because download from a local server URL that appears earlier + // in a response is preferable than downloading from the next URL which + // could be a internet URL and thus could be more expensive). case ErrorCode::kError: case ErrorCode::kDownloadTransferError: @@ -369,22 +368,22 @@ void PayloadState::UpdateFailed(ErrorCode error) { LOG(INFO) << "Not incrementing URL index or failure count for this error"; break; - case ErrorCode::kSuccess: // success code - case ErrorCode::kUmaReportedMax: // not an error code - case ErrorCode::kOmahaRequestHTTPResponseBase: // aggregated already - case ErrorCode::kDevModeFlag: // not an error code - case ErrorCode::kResumedFlag: // not an error code - case ErrorCode::kTestImageFlag: // not an error code - case ErrorCode::kTestOmahaUrlFlag: // not an error code - case ErrorCode::kSpecialFlags: // not an error code + case ErrorCode::kSuccess: // success code + case ErrorCode::kUmaReportedMax: // not an error code + case ErrorCode::kOmahaRequestHTTPResponseBase: // aggregated already + case ErrorCode::kDevModeFlag: // not an error code + case ErrorCode::kResumedFlag: // not an error code + case ErrorCode::kTestImageFlag: // not an error code + case ErrorCode::kTestOmahaUrlFlag: // not an error code + case ErrorCode::kSpecialFlags: // not an error code // These shouldn't happen. Enumerating these explicitly here so that we // can let the compiler warn about new error codes that are added to // action_processor.h but not added here. LOG(WARNING) << "Unexpected error code for UpdateFailed"; break; - // Note: Not adding a default here so as to let the compiler warn us of - // any new enums that were added in the .h but not listed in this switch. + // Note: Not adding a default here so as to let the compiler warn us of + // any new enums that were added in the .h but not listed in this switch. } } @@ -531,8 +530,8 @@ void PayloadState::UpdateBackoffExpiryTime() { // We don't want all retries to happen exactly at the same time when // retrying after backoff. So add some random minutes to fuzz. int fuzz_minutes = utils::FuzzInt(0, kMaxBackoffFuzzMinutes); - TimeDelta next_backoff_interval = TimeDelta::FromDays(num_days) + - TimeDelta::FromMinutes(fuzz_minutes); + TimeDelta next_backoff_interval = + TimeDelta::FromDays(num_days) + TimeDelta::FromMinutes(fuzz_minutes); LOG(INFO) << "Incrementing the backoff expiry time by " << utils::FormatTimeDelta(next_backoff_interval); SetBackoffExpiryTime(Time::Now() + next_backoff_interval); @@ -600,10 +599,10 @@ void PayloadState::CollectAndReportAttemptMetrics(ErrorCode code) { int64_t payload_bytes_downloaded = attempt_num_bytes_downloaded_; - ClockInterface *clock = system_state_->clock(); + ClockInterface* clock = system_state_->clock(); TimeDelta duration = clock->GetBootTime() - attempt_start_time_boot_; - TimeDelta duration_uptime = clock->GetMonotonicTime() - - attempt_start_time_monotonic_; + TimeDelta duration_uptime = + clock->GetMonotonicTime() - attempt_start_time_monotonic_; int64_t payload_download_speed_bps = 0; int64_t usec = duration_uptime.InMicroseconds(); @@ -616,7 +615,7 @@ void PayloadState::CollectAndReportAttemptMetrics(ErrorCode code) { DownloadSource download_source = current_download_source_; metrics::DownloadErrorCode payload_download_error_code = - metrics::DownloadErrorCode::kUnset; + metrics::DownloadErrorCode::kUnset; ErrorCode internal_error_code = ErrorCode::kSuccess; metrics::AttemptResult attempt_result = metrics_utils::GetAttemptResult(code); @@ -730,8 +729,8 @@ void PayloadState::CollectAndReportSuccessfulUpdateMetrics() { int download_overhead_percentage = 0; if (successful_bytes > 0) { - download_overhead_percentage = (total_bytes - successful_bytes) * 100ULL / - successful_bytes; + download_overhead_percentage = + (total_bytes - successful_bytes) * 100ULL / successful_bytes; } int url_switch_count = static_cast<int>(url_switch_count_); @@ -887,7 +886,7 @@ void PayloadState::SetFullPayloadAttemptNumber( full_payload_attempt_number_ = full_payload_attempt_number; LOG(INFO) << "Full Payload Attempt Number = " << full_payload_attempt_number_; prefs_->SetInt64(kPrefsFullPayloadAttemptNumber, - full_payload_attempt_number_); + full_payload_attempt_number_); } void PayloadState::SetPayloadIndex(size_t payload_index) { @@ -1007,8 +1006,8 @@ void PayloadState::SetBackoffExpiryTime(const Time& new_time) { TimeDelta PayloadState::GetUpdateDuration() { Time end_time = update_timestamp_end_.is_null() - ? system_state_->clock()->GetWallclockTime() : - update_timestamp_end_; + ? system_state_->clock()->GetWallclockTime() + : update_timestamp_end_; return end_time - update_timestamp_start_; } @@ -1038,8 +1037,7 @@ void PayloadState::LoadUpdateTimestampStart() { TimeDelta duration_according_to_stored_time = now - stored_time; if (duration_according_to_stored_time < -kDurationSlack) { LOG(ERROR) << "The UpdateTimestampStart value (" - << utils::ToString(stored_time) - << ") in persisted state is " + << utils::ToString(stored_time) << ") in persisted state is " << utils::FormatTimeDelta(duration_according_to_stored_time) << " in the future. Resetting."; stored_time = now; @@ -1086,8 +1084,7 @@ void PayloadState::LoadUpdateDurationUptime() { if (diff < -kDurationSlack) { LOG(ERROR) << "The UpdateDurationUptime value (" << utils::FormatTimeDelta(stored_delta) - << ") in persisted state is " - << utils::FormatTimeDelta(diff) + << ") in persisted state is " << utils::FormatTimeDelta(diff) << " larger than the wall-clock delta. Resetting."; stored_delta = update_duration_current_; } @@ -1129,7 +1126,7 @@ void PayloadState::LoadRollbackVersion() { void PayloadState::SetRollbackVersion(const string& rollback_version) { CHECK(powerwash_safe_prefs_); - LOG(INFO) << "Blacklisting version "<< rollback_version; + LOG(INFO) << "Blacklisting version " << rollback_version; rollback_version_ = rollback_version; powerwash_safe_prefs_->SetString(kPrefsRollbackVersion, rollback_version); } @@ -1173,10 +1170,9 @@ void PayloadState::LoadCurrentBytesDownloaded(DownloadSource source) { SetCurrentBytesDownloaded(source, GetPersistedValue(key, prefs_), true); } -void PayloadState::SetCurrentBytesDownloaded( - DownloadSource source, - uint64_t current_bytes_downloaded, - bool log) { +void PayloadState::SetCurrentBytesDownloaded(DownloadSource source, + uint64_t current_bytes_downloaded, + bool log) { CHECK(prefs_); if (source >= kNumDownloadSources) @@ -1197,10 +1193,9 @@ void PayloadState::LoadTotalBytesDownloaded(DownloadSource source) { SetTotalBytesDownloaded(source, GetPersistedValue(key, prefs_), true); } -void PayloadState::SetTotalBytesDownloaded( - DownloadSource source, - uint64_t total_bytes_downloaded, - bool log) { +void PayloadState::SetTotalBytesDownloaded(DownloadSource source, + uint64_t total_bytes_downloaded, + bool log) { CHECK(prefs_); if (source >= kNumDownloadSources) @@ -1212,9 +1207,8 @@ void PayloadState::SetTotalBytesDownloaded( // Persist. string prefs_key = GetPrefsKey(kPrefsTotalBytesDownloaded, source); prefs_->SetInt64(prefs_key, total_bytes_downloaded); - LOG_IF(INFO, log) << "Total bytes downloaded for " - << utils::ToString(source) << " = " - << GetTotalBytesDownloaded(source); + LOG_IF(INFO, log) << "Total bytes downloaded for " << utils::ToString(source) + << " = " << GetTotalBytesDownloaded(source); } void PayloadState::LoadNumResponsesSeen() { @@ -1400,8 +1394,7 @@ void PayloadState::P2PNewAttempt() { bool PayloadState::P2PAttemptAllowed() { if (p2p_num_attempts_ > kMaxP2PAttempts) { LOG(INFO) << "Number of p2p attempts is " << p2p_num_attempts_ - << " which is greater than " - << kMaxP2PAttempts + << " which is greater than " << kMaxP2PAttempts << " - disallowing p2p."; return false; } @@ -1418,8 +1411,8 @@ bool PayloadState::P2PAttemptAllowed() { LOG(INFO) << "Time spent attempting p2p is " << utils::FormatTimeDelta(time_spent_attempting_p2p) << " which is greater than " - << utils::FormatTimeDelta(TimeDelta::FromSeconds( - kMaxP2PAttemptTimeSeconds)) + << utils::FormatTimeDelta( + TimeDelta::FromSeconds(kMaxP2PAttemptTimeSeconds)) << " - disallowing p2p."; return false; } diff --git a/payload_state.h b/payload_state.h index cb6454f4..5ef12202 100644 --- a/payload_state.h +++ b/payload_state.h @@ -86,17 +86,11 @@ class PayloadState : public PayloadStateInterface { : ""; } - inline uint32_t GetUrlFailureCount() override { - return url_failure_count_; - } + inline uint32_t GetUrlFailureCount() override { return url_failure_count_; } - inline uint32_t GetUrlSwitchCount() override { - return url_switch_count_; - } + inline uint32_t GetUrlSwitchCount() override { return url_switch_count_; } - inline int GetNumResponsesSeen() override { - return num_responses_seen_; - } + inline int GetNumResponsesSeen() override { return num_responses_seen_; } inline base::Time GetBackoffExpiryTime() override { return backoff_expiry_time_; @@ -114,9 +108,7 @@ class PayloadState : public PayloadStateInterface { return source < kNumDownloadSources ? total_bytes_downloaded_[source] : 0; } - inline uint32_t GetNumReboots() override { - return num_reboots_; - } + inline uint32_t GetNumReboots() override { return num_reboots_; } void UpdateEngineStarted() override; @@ -124,9 +116,7 @@ class PayloadState : public PayloadStateInterface { void SetRollbackHappened(bool rollback_happened) override; - inline std::string GetRollbackVersion() override { - return rollback_version_; - } + inline std::string GetRollbackVersion() override { return rollback_version_; } int GetP2PNumAttempts() override; base::Time GetP2PFirstAttemptTimestamp() override; @@ -137,9 +127,7 @@ class PayloadState : public PayloadStateInterface { return using_p2p_for_downloading_; } - bool GetUsingP2PForSharing() const override { - return using_p2p_for_sharing_; - } + bool GetUsingP2PForSharing() const override { return using_p2p_for_sharing_; } base::TimeDelta GetScatteringWaitPeriod() override { return scattering_wait_period_; @@ -149,13 +137,9 @@ class PayloadState : public PayloadStateInterface { void SetStagingWaitPeriod(base::TimeDelta wait_period) override; - void SetP2PUrl(const std::string& url) override { - p2p_url_ = url; - } + void SetP2PUrl(const std::string& url) override { p2p_url_ = url; } - std::string GetP2PUrl() const override { - return p2p_url_; - } + std::string GetP2PUrl() const override { return p2p_url_; } bool NextPayload() override; diff --git a/payload_state_unittest.cc b/payload_state_unittest.cc index 637891b4..869c24eb 100644 --- a/payload_state_unittest.cc +++ b/payload_state_unittest.cc @@ -37,28 +37,28 @@ using base::Time; using base::TimeDelta; using std::string; +using testing::_; using testing::AnyNumber; using testing::AtLeast; using testing::Mock; using testing::NiceMock; using testing::Return; using testing::SetArgPointee; -using testing::_; namespace chromeos_update_engine { const char* kCurrentBytesDownloadedFromHttps = - "current-bytes-downloaded-from-HttpsServer"; + "current-bytes-downloaded-from-HttpsServer"; const char* kTotalBytesDownloadedFromHttps = - "total-bytes-downloaded-from-HttpsServer"; + "total-bytes-downloaded-from-HttpsServer"; const char* kCurrentBytesDownloadedFromHttp = - "current-bytes-downloaded-from-HttpServer"; + "current-bytes-downloaded-from-HttpServer"; const char* kTotalBytesDownloadedFromHttp = - "total-bytes-downloaded-from-HttpServer"; + "total-bytes-downloaded-from-HttpServer"; const char* kCurrentBytesDownloadedFromHttpPeer = - "current-bytes-downloaded-from-HttpPeer"; + "current-bytes-downloaded-from-HttpPeer"; const char* kTotalBytesDownloadedFromHttpPeer = - "total-bytes-downloaded-from-HttpPeer"; + "total-bytes-downloaded-from-HttpPeer"; static void SetupPayloadStateWith2Urls(string hash, bool http_enabled, @@ -103,7 +103,7 @@ static void SetupPayloadStateWith2Urls(string hash, EXPECT_EQ(expected_response_sign, stored_response_sign); } -class PayloadStateTest : public ::testing::Test { }; +class PayloadStateTest : public ::testing::Test {}; TEST(PayloadStateTest, SetResponseWorksWithEmptyResponse) { OmahaResponse response; @@ -111,23 +111,23 @@ TEST(PayloadStateTest, SetResponseWorksWithEmptyResponse) { NiceMock<MockPrefs>* prefs = fake_system_state.mock_prefs(); EXPECT_CALL(*prefs, SetInt64(_, _)).Times(AnyNumber()); EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsBackoffExpiryTime, 0)).Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsUpdateTimestampStart, _)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsUpdateDurationUptime, _)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttps, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttp, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttpPeer, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsNumReboots, 0)).Times(AtLeast(1)); PayloadState payload_state; EXPECT_TRUE(payload_state.Initialize(&fake_system_state)); @@ -154,27 +154,24 @@ TEST(PayloadStateTest, SetResponseWorksWithSingleUrl) { NiceMock<MockPrefs>* prefs = fake_system_state.mock_prefs(); EXPECT_CALL(*prefs, SetInt64(_, _)).Times(AnyNumber()); EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 0)) - .Times(AtLeast(1)); - EXPECT_CALL(*prefs, SetInt64(kPrefsBackoffExpiryTime, 0)) - .Times(AtLeast(1)); - EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlIndex, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsBackoffExpiryTime, 0)).Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsUpdateTimestampStart, _)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsUpdateDurationUptime, _)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttps, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttp, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttpPeer, 0)) - .Times(AtLeast(1)); - EXPECT_CALL(*prefs, SetInt64(kPrefsNumReboots, 0)) .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsNumReboots, 0)).Times(AtLeast(1)); PayloadState payload_state; EXPECT_TRUE(payload_state.Initialize(&fake_system_state)); payload_state.SetResponse(response); @@ -209,23 +206,20 @@ TEST(PayloadStateTest, SetResponseWorksWithMultipleUrls) { NiceMock<MockPrefs>* prefs = fake_system_state.mock_prefs(); EXPECT_CALL(*prefs, SetInt64(_, _)).Times(AnyNumber()); EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 0)) - .Times(AtLeast(1)); - EXPECT_CALL(*prefs, SetInt64(kPrefsBackoffExpiryTime, 0)) - .Times(AtLeast(1)); - EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlIndex, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsBackoffExpiryTime, 0)).Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttps, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttp, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttpPeer, 0)) - .Times(AtLeast(1)); - EXPECT_CALL(*prefs, SetInt64(kPrefsNumReboots, 0)) .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsNumReboots, 0)).Times(AtLeast(1)); PayloadState payload_state; EXPECT_TRUE(payload_state.Initialize(&fake_system_state)); @@ -259,13 +253,13 @@ TEST(PayloadStateTest, CanAdvanceUrlIndexCorrectly) { EXPECT_CALL(*prefs, SetInt64(_, _)).Times(AnyNumber()); // Payload attempt should start with 0 and then advance to 1. EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 1)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 1)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsBackoffExpiryTime, _)).Times(AtLeast(2)); // Reboots will be set @@ -278,7 +272,7 @@ TEST(PayloadStateTest, CanAdvanceUrlIndexCorrectly) { // Failure count should be called each times url index is set, so that's // 4 times for this test. EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)) - .Times(AtLeast(4)); + .Times(AtLeast(4)); EXPECT_TRUE(payload_state.Initialize(&fake_system_state)); @@ -361,18 +355,18 @@ TEST(PayloadStateTest, AllCountersGetUpdatedProperlyOnErrorCodesAndEvents) { EXPECT_CALL(*prefs, SetInt64(_, _)).Times(AnyNumber()); EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)) - .Times(AtLeast(2)); + .Times(AtLeast(2)); EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 1)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 2)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 0)) - .Times(AtLeast(2)); + .Times(AtLeast(2)); EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 1)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 2)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsBackoffExpiryTime, _)).Times(AtLeast(4)); @@ -380,29 +374,28 @@ TEST(PayloadStateTest, AllCountersGetUpdatedProperlyOnErrorCodesAndEvents) { EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlIndex, 1)).Times(AtLeast(2)); EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)) - .Times(AtLeast(7)); + .Times(AtLeast(7)); EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlFailureCount, 1)) - .Times(AtLeast(2)); + .Times(AtLeast(2)); EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlFailureCount, 2)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsUpdateTimestampStart, _)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsUpdateDurationUptime, _)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttps, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttp, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttpPeer, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttp, progress_bytes)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kTotalBytesDownloadedFromHttp, progress_bytes)) - .Times(AtLeast(1)); - EXPECT_CALL(*prefs, SetInt64(kPrefsNumReboots, 0)) .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsNumReboots, 0)).Times(AtLeast(1)); EXPECT_TRUE(payload_state.Initialize(&fake_system_state)); @@ -507,22 +500,20 @@ TEST(PayloadStateTest, PayloadAttemptNumberIncreasesOnSuccessfulFullDownload) { EXPECT_CALL(*prefs, SetInt64(_, _)).Times(AnyNumber()); EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 1)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 1)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); - EXPECT_CALL(*prefs, SetInt64(kPrefsBackoffExpiryTime, _)) - .Times(AtLeast(2)); + EXPECT_CALL(*prefs, SetInt64(kPrefsBackoffExpiryTime, _)).Times(AtLeast(2)); - EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlIndex, 0)) - .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_TRUE(payload_state.Initialize(&fake_system_state)); @@ -548,21 +539,19 @@ TEST(PayloadStateTest, PayloadAttemptNumberIncreasesOnSuccessfulDeltaDownload) { EXPECT_CALL(*prefs, SetInt64(_, _)).Times(AnyNumber()); EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 1)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); // kPrefsFullPayloadAttemptNumber is not incremented for delta payloads. EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); - EXPECT_CALL(*prefs, SetInt64(kPrefsBackoffExpiryTime, _)) - .Times(1); + EXPECT_CALL(*prefs, SetInt64(kPrefsBackoffExpiryTime, _)).Times(1); - EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlIndex, 0)) - .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(AtLeast(1)); EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_TRUE(payload_state.Initialize(&fake_system_state)); @@ -607,15 +596,14 @@ TEST(PayloadStateTest, SetResponseResetsInvalidUrlIndex) { EXPECT_CALL(*prefs2, Exists(_)).WillRepeatedly(Return(true)); EXPECT_CALL(*prefs2, GetInt64(_, _)).Times(AtLeast(1)); EXPECT_CALL(*prefs2, GetInt64(kPrefsPayloadAttemptNumber, _)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs2, GetInt64(kPrefsFullPayloadAttemptNumber, _)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); EXPECT_CALL(*prefs2, GetInt64(kPrefsCurrentUrlIndex, _)) .WillRepeatedly(DoAll(SetArgPointee<1>(2), Return(true))); EXPECT_CALL(*prefs2, GetInt64(kPrefsCurrentUrlFailureCount, _)) - .Times(AtLeast(1)); - EXPECT_CALL(*prefs2, GetInt64(kPrefsUrlSwitchCount, _)) - .Times(AtLeast(1)); + .Times(AtLeast(1)); + EXPECT_CALL(*prefs2, GetInt64(kPrefsUrlSwitchCount, _)).Times(AtLeast(1)); // Note: This will be a different payload object, but the response should // have the same hash as before so as to not trivially reset because the @@ -719,7 +707,7 @@ static void CheckPayloadBackoffState(PayloadState* payload_state, TimeDelta expected_days) { payload_state->DownloadComplete(); EXPECT_EQ(expected_attempt_number, - payload_state->GetFullPayloadAttemptNumber()); + payload_state->GetFullPayloadAttemptNumber()); EXPECT_TRUE(payload_state->ShouldBackoffDownload()); Time backoff_expiry_time = payload_state->GetBackoffExpiryTime(); // Add 1 hour extra to the 6 hour fuzz check to tolerate edge cases. @@ -741,16 +729,16 @@ TEST(PayloadStateTest, BackoffPeriodsAreInCorrectRange) { SetupPayloadStateWith2Urls( "Hash8939", true, false, &payload_state, &response); - CheckPayloadBackoffState(&payload_state, 1, TimeDelta::FromDays(1)); - CheckPayloadBackoffState(&payload_state, 2, TimeDelta::FromDays(2)); - CheckPayloadBackoffState(&payload_state, 3, TimeDelta::FromDays(4)); - CheckPayloadBackoffState(&payload_state, 4, TimeDelta::FromDays(8)); - CheckPayloadBackoffState(&payload_state, 5, TimeDelta::FromDays(16)); - CheckPayloadBackoffState(&payload_state, 6, TimeDelta::FromDays(16)); - CheckPayloadBackoffState(&payload_state, 7, TimeDelta::FromDays(16)); - CheckPayloadBackoffState(&payload_state, 8, TimeDelta::FromDays(16)); - CheckPayloadBackoffState(&payload_state, 9, TimeDelta::FromDays(16)); - CheckPayloadBackoffState(&payload_state, 10, TimeDelta::FromDays(16)); + CheckPayloadBackoffState(&payload_state, 1, TimeDelta::FromDays(1)); + CheckPayloadBackoffState(&payload_state, 2, TimeDelta::FromDays(2)); + CheckPayloadBackoffState(&payload_state, 3, TimeDelta::FromDays(4)); + CheckPayloadBackoffState(&payload_state, 4, TimeDelta::FromDays(8)); + CheckPayloadBackoffState(&payload_state, 5, TimeDelta::FromDays(16)); + CheckPayloadBackoffState(&payload_state, 6, TimeDelta::FromDays(16)); + CheckPayloadBackoffState(&payload_state, 7, TimeDelta::FromDays(16)); + CheckPayloadBackoffState(&payload_state, 8, TimeDelta::FromDays(16)); + CheckPayloadBackoffState(&payload_state, 9, TimeDelta::FromDays(16)); + CheckPayloadBackoffState(&payload_state, 10, TimeDelta::FromDays(16)); } TEST(PayloadStateTest, BackoffLogicCanBeDisabled) { @@ -820,8 +808,8 @@ TEST(PayloadStateTest, BytesDownloadedMetricsGetAddedToCorrectSources) { payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpServer)); EXPECT_EQ(http_total, payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpServer)); - EXPECT_EQ(0U, payload_state.GetCurrentBytesDownloaded( - kDownloadSourceHttpsServer)); + EXPECT_EQ( + 0U, payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpsServer)); EXPECT_EQ(https_total, payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpsServer)); @@ -837,8 +825,9 @@ TEST(PayloadStateTest, BytesDownloadedMetricsGetAddedToCorrectSources) { payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpServer)); EXPECT_EQ(http_total, payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpServer)); - EXPECT_EQ(second_chunk, payload_state.GetCurrentBytesDownloaded( - kDownloadSourceHttpsServer)); + EXPECT_EQ( + second_chunk, + payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpsServer)); EXPECT_EQ(https_total, payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpsServer)); @@ -854,8 +843,9 @@ TEST(PayloadStateTest, BytesDownloadedMetricsGetAddedToCorrectSources) { payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpServer)); EXPECT_EQ(http_total, payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpServer)); - EXPECT_EQ(second_chunk, payload_state.GetCurrentBytesDownloaded( - kDownloadSourceHttpsServer)); + EXPECT_EQ( + second_chunk, + payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpsServer)); EXPECT_EQ(https_total, payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpsServer)); @@ -880,8 +870,8 @@ TEST(PayloadStateTest, BytesDownloadedMetricsGetAddedToCorrectSources) { payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpServer)); EXPECT_EQ(0U, payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpServer)); - EXPECT_EQ(0U, payload_state.GetCurrentBytesDownloaded( - kDownloadSourceHttpsServer)); + EXPECT_EQ( + 0U, payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpsServer)); EXPECT_EQ(0U, payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpsServer)); EXPECT_EQ(0, payload_state.GetNumResponsesSeen()); @@ -944,8 +934,8 @@ TEST(PayloadStateTest, RestartingUpdateResetsMetrics) { payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpServer)); EXPECT_EQ(num_bytes, payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpServer)); - EXPECT_EQ(0U, payload_state.GetCurrentBytesDownloaded( - kDownloadSourceHttpsServer)); + EXPECT_EQ( + 0U, payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpsServer)); EXPECT_EQ(0U, payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpsServer)); @@ -1033,8 +1023,8 @@ TEST(PayloadStateTest, RollbackVersion) { params.Init(rollback_version, "", false); fake_system_state.set_request_params(¶ms); - EXPECT_CALL(*mock_powerwash_safe_prefs, SetString(kPrefsRollbackVersion, - rollback_version)); + EXPECT_CALL(*mock_powerwash_safe_prefs, + SetString(kPrefsRollbackVersion, rollback_version)); payload_state.Rollback(); EXPECT_EQ(rollback_version, payload_state.GetRollbackVersion()); @@ -1042,11 +1032,10 @@ TEST(PayloadStateTest, RollbackVersion) { // Change it up a little and verify we load it correctly. rollback_version = "2345.0.1"; // Let's verify we can reload it correctly. - EXPECT_CALL(*mock_powerwash_safe_prefs, GetString( - kPrefsRollbackVersion, _)).WillOnce(DoAll( - SetArgPointee<1>(rollback_version), Return(true))); - EXPECT_CALL(*mock_powerwash_safe_prefs, SetString(kPrefsRollbackVersion, - rollback_version)); + EXPECT_CALL(*mock_powerwash_safe_prefs, GetString(kPrefsRollbackVersion, _)) + .WillOnce(DoAll(SetArgPointee<1>(rollback_version), Return(true))); + EXPECT_CALL(*mock_powerwash_safe_prefs, + SetString(kPrefsRollbackVersion, rollback_version)); payload_state.LoadRollbackVersion(); EXPECT_EQ(rollback_version, payload_state.GetRollbackVersion()); @@ -1570,8 +1559,8 @@ TEST(PayloadStateTest, DisallowP2PAfterDeadline) { EXPECT_TRUE(payload_state.P2PAttemptAllowed()); // Set clock to half the deadline - this should work. - fake_clock.SetWallclockTime(epoch + - TimeDelta::FromSeconds(kMaxP2PAttemptTimeSeconds) / 2); + fake_clock.SetWallclockTime( + epoch + TimeDelta::FromSeconds(kMaxP2PAttemptTimeSeconds) / 2); EXPECT_TRUE(payload_state.P2PAttemptAllowed()); // Check that the first attempt timestamp hasn't changed just @@ -1579,13 +1568,13 @@ TEST(PayloadStateTest, DisallowP2PAfterDeadline) { EXPECT_EQ(epoch, payload_state.GetP2PFirstAttemptTimestamp()); // Set clock to _just_ before the deadline - this should work. - fake_clock.SetWallclockTime(epoch + - TimeDelta::FromSeconds(kMaxP2PAttemptTimeSeconds - 1)); + fake_clock.SetWallclockTime( + epoch + TimeDelta::FromSeconds(kMaxP2PAttemptTimeSeconds - 1)); EXPECT_TRUE(payload_state.P2PAttemptAllowed()); // Set clock to _just_ after the deadline - this should not work. - fake_clock.SetWallclockTime(epoch + - TimeDelta::FromSeconds(kMaxP2PAttemptTimeSeconds + 1)); + fake_clock.SetWallclockTime( + epoch + TimeDelta::FromSeconds(kMaxP2PAttemptTimeSeconds + 1)); EXPECT_FALSE(payload_state.P2PAttemptAllowed()); } diff --git a/power_manager_android.cc b/power_manager_android.cc index 6b7e8809..63a0351e 100644 --- a/power_manager_android.cc +++ b/power_manager_android.cc @@ -16,6 +16,8 @@ #include "update_engine/power_manager_android.h" +#include <memory> + #include <base/logging.h> namespace chromeos_update_engine { @@ -24,7 +26,7 @@ namespace power_manager { std::unique_ptr<PowerManagerInterface> CreatePowerManager() { return std::unique_ptr<PowerManagerInterface>(new PowerManagerAndroid()); } -} +} // namespace power_manager bool PowerManagerAndroid::RequestReboot() { LOG(WARNING) << "PowerManager not implemented."; diff --git a/power_manager_chromeos.cc b/power_manager_chromeos.cc index 23fb0325..531d367d 100644 --- a/power_manager_chromeos.cc +++ b/power_manager_chromeos.cc @@ -29,7 +29,7 @@ namespace power_manager { std::unique_ptr<PowerManagerInterface> CreatePowerManager() { return std::unique_ptr<PowerManagerInterface>(new PowerManagerChromeOS()); } -} +} // namespace power_manager PowerManagerChromeOS::PowerManagerChromeOS() : power_manager_proxy_(DBusConnection::Get()->GetDBus()) {} diff --git a/power_manager_interface.h b/power_manager_interface.h index be059ec0..8f776500 100644 --- a/power_manager_interface.h +++ b/power_manager_interface.h @@ -40,7 +40,7 @@ class PowerManagerInterface { namespace power_manager { // Factory function which create a PowerManager. std::unique_ptr<PowerManagerInterface> CreatePowerManager(); -} +} // namespace power_manager } // namespace chromeos_update_engine diff --git a/real_system_state.cc b/real_system_state.cc index 9474741f..2f18b4d6 100644 --- a/real_system_state.cc +++ b/real_system_state.cc @@ -149,8 +149,8 @@ bool RealSystemState::Initialize() { new CertificateChecker(prefs_.get(), &openssl_wrapper_)); certificate_checker_->Init(); - update_attempter_.reset(new UpdateAttempter(this, - certificate_checker_.get())); + update_attempter_.reset( + new UpdateAttempter(this, certificate_checker_.get())); // Initialize the UpdateAttempter before the UpdateManager. update_attempter_->Init(); @@ -169,15 +169,20 @@ bool RealSystemState::Initialize() { LOG(ERROR) << "Failed to initialize the Update Manager."; return false; } - update_manager_.reset( - new chromeos_update_manager::UpdateManager( - &clock_, base::TimeDelta::FromSeconds(5), - base::TimeDelta::FromHours(12), um_state)); + update_manager_.reset(new chromeos_update_manager::UpdateManager( + &clock_, + base::TimeDelta::FromSeconds(5), + base::TimeDelta::FromHours(12), + um_state)); // The P2P Manager depends on the Update Manager for its initialization. - p2p_manager_.reset(P2PManager::Construct( - nullptr, &clock_, update_manager_.get(), "cros_au", - kMaxP2PFilesToKeep, base::TimeDelta::FromDays(kMaxP2PFileAgeDays))); + p2p_manager_.reset( + P2PManager::Construct(nullptr, + &clock_, + update_manager_.get(), + "cros_au", + kMaxP2PFilesToKeep, + base::TimeDelta::FromDays(kMaxP2PFileAgeDays))); if (!payload_state_.Initialize(this)) { LOG(ERROR) << "Failed to initialize the payload state object."; @@ -215,14 +220,16 @@ bool RealSystemState::StartUpdater() { // Broadcast the update engine status on startup to ensure consistent system // state on crashes. - MessageLoop::current()->PostTask(FROM_HERE, base::Bind( - &UpdateAttempter::BroadcastStatus, - base::Unretained(update_attempter_.get()))); + MessageLoop::current()->PostTask( + FROM_HERE, + base::Bind(&UpdateAttempter::BroadcastStatus, + base::Unretained(update_attempter_.get()))); // Run the UpdateEngineStarted() method on |update_attempter|. - MessageLoop::current()->PostTask(FROM_HERE, base::Bind( - &UpdateAttempter::UpdateEngineStarted, - base::Unretained(update_attempter_.get()))); + MessageLoop::current()->PostTask( + FROM_HERE, + base::Bind(&UpdateAttempter::UpdateEngineStarted, + base::Unretained(update_attempter_.get()))); return true; } diff --git a/sideload_main.cc b/sideload_main.cc index 4bbb4b8c..818fa5c9 100644 --- a/sideload_main.cc +++ b/sideload_main.cc @@ -40,8 +40,8 @@ using std::string; using std::vector; -using update_engine::UpdateStatus; using update_engine::UpdateEngineStatus; +using update_engine::UpdateStatus; namespace chromeos_update_engine { namespace { diff --git a/test_http_server.cc b/test_http_server.cc index cf156720..4536f372 100644 --- a/test_http_server.cc +++ b/test_http_server.cc @@ -48,14 +48,12 @@ #include "update_engine/common/http_common.h" - // HTTP end-of-line delimiter; sorry, this needs to be a macro. #define EOL "\r\n" using std::string; using std::vector; - namespace chromeos_update_engine { static const char* kListeningMsgPrefix = "listening on port "; @@ -93,8 +91,7 @@ bool ParseRequest(int fd, HttpRequest* request) { } while (!base::EndsWith(headers, EOL EOL, base::CompareCase::SENSITIVE)); LOG(INFO) << "got headers:\n--8<------8<------8<------8<----\n" - << headers - << "\n--8<------8<------8<------8<----"; + << headers << "\n--8<------8<------8<------8<----"; request->raw_headers = headers; // Break header into lines. @@ -105,7 +102,8 @@ bool ParseRequest(int fd, HttpRequest* request) { base::SPLIT_WANT_ALL); // Decode URL line. - vector<string> terms = base::SplitString(lines[0], base::kWhitespaceASCII, + vector<string> terms = base::SplitString(lines[0], + base::kWhitespaceASCII, base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY); CHECK_EQ(terms.size(), static_cast<vector<string>::size_type>(3)); @@ -116,12 +114,14 @@ bool ParseRequest(int fd, HttpRequest* request) { // Decode remaining lines. size_t i; for (i = 1; i < lines.size(); i++) { - terms = base::SplitString(lines[i], base::kWhitespaceASCII, - base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY); + terms = base::SplitString(lines[i], + base::kWhitespaceASCII, + base::KEEP_WHITESPACE, + base::SPLIT_WANT_NONEMPTY); if (terms[0] == "Range:") { CHECK_EQ(terms.size(), static_cast<vector<string>::size_type>(2)); - string &range = terms[1]; + string& range = terms[1]; LOG(INFO) << "range attribute: " << range; CHECK(base::StartsWith(range, "bytes=", base::CompareCase::SENSITIVE) && range.find('-') != string::npos); @@ -130,12 +130,13 @@ bool ParseRequest(int fd, HttpRequest* request) { if (range.find('-') < range.length() - 1) request->end_offset = atoll(range.c_str() + range.find('-') + 1) + 1; request->return_code = kHttpResponsePartialContent; - string tmp_str = base::StringPrintf("decoded range offsets: " - "start=%jd end=", - (intmax_t)request->start_offset); + string tmp_str = base::StringPrintf( + "decoded range offsets: " + "start=%jd end=", + (intmax_t)request->start_offset); if (request->end_offset > 0) - base::StringAppendF(&tmp_str, "%jd (non-inclusive)", - (intmax_t)request->end_offset); + base::StringAppendF( + &tmp_str, "%jd (non-inclusive)", (intmax_t)request->end_offset); else base::StringAppendF(&tmp_str, "unspecified"); LOG(INFO) << tmp_str; @@ -162,7 +163,7 @@ string Itoa(off_t num) { ssize_t WriteString(int fd, const string& str) { const size_t total_size = str.size(); size_t remaining_size = total_size; - char const *data = str.data(); + char const* data = str.data(); while (remaining_size) { ssize_t written = write(fd, data, remaining_size); @@ -179,38 +180,38 @@ ssize_t WriteString(int fd, const string& str) { } // Writes the headers of an HTTP response into a file. -ssize_t WriteHeaders(int fd, const off_t start_offset, const off_t end_offset, +ssize_t WriteHeaders(int fd, + const off_t start_offset, + const off_t end_offset, HttpResponseCode return_code) { ssize_t written = 0, ret; ret = WriteString(fd, string("HTTP/1.1 ") + Itoa(return_code) + " " + - GetHttpResponseDescription(return_code) + - EOL - "Content-Type: application/octet-stream" EOL); + GetHttpResponseDescription(return_code) + + EOL "Content-Type: application/octet-stream" EOL); if (ret < 0) return -1; written += ret; // Compute content legnth. - const off_t content_length = end_offset - start_offset;; + const off_t content_length = end_offset - start_offset; // A start offset that equals the end offset indicates that the response // should contain the full range of bytes in the requested resource. if (start_offset || start_offset == end_offset) { - ret = WriteString(fd, - string("Accept-Ranges: bytes" EOL - "Content-Range: bytes ") + - Itoa(start_offset == end_offset ? 0 : start_offset) + - "-" + Itoa(end_offset - 1) + "/" + Itoa(end_offset) + - EOL); + ret = WriteString( + fd, + string("Accept-Ranges: bytes" EOL "Content-Range: bytes ") + + Itoa(start_offset == end_offset ? 0 : start_offset) + "-" + + Itoa(end_offset - 1) + "/" + Itoa(end_offset) + EOL); if (ret < 0) return -1; written += ret; } - ret = WriteString(fd, string("Content-Length: ") + Itoa(content_length) + - EOL EOL); + ret = WriteString( + fd, string("Content-Length: ") + Itoa(content_length) + EOL EOL); if (ret < 0) return -1; written += ret; @@ -221,8 +222,11 @@ ssize_t WriteHeaders(int fd, const off_t start_offset, const off_t end_offset, // Writes a predetermined payload of lines of ascending bytes to a file. The // first byte of output is appropriately offset with respect to the request line // length. Returns the number of successfully written bytes. -size_t WritePayload(int fd, const off_t start_offset, const off_t end_offset, - const char first_byte, const size_t line_len) { +size_t WritePayload(int fd, + const off_t start_offset, + const off_t end_offset, + const char first_byte, + const size_t line_len) { CHECK_LE(start_offset, end_offset); CHECK_GT(line_len, static_cast<size_t>(0)); @@ -248,14 +252,14 @@ size_t WritePayload(int fd, const off_t start_offset, const off_t end_offset, if (start_modulo) { string partial = line.substr(start_modulo, remaining_len); ssize_t ret = WriteString(fd, partial); - if ((success = (ret >= 0 && (size_t) ret == partial.length()))) + if ((success = (ret >= 0 && (size_t)ret == partial.length()))) remaining_len -= partial.length(); } // Output full lines up to the maximal line boundary below the end offset. while (success && remaining_len >= line_len) { ssize_t ret = WriteString(fd, line); - if ((success = (ret >= 0 && (size_t) ret == line_len))) + if ((success = (ret >= 0 && (size_t)ret == line_len))) remaining_len -= line_len; } @@ -263,7 +267,7 @@ size_t WritePayload(int fd, const off_t start_offset, const off_t end_offset, if (success && remaining_len) { string partial = line.substr(0, remaining_len); ssize_t ret = WriteString(fd, partial); - if ((success = (ret >= 0 && (size_t) ret == partial.length()))) + if ((success = (ret >= 0 && (size_t)ret == partial.length()))) remaining_len -= partial.length(); } @@ -271,7 +275,8 @@ size_t WritePayload(int fd, const off_t start_offset, const off_t end_offset, } // Write default payload lines of the form 'abcdefghij'. -inline size_t WritePayload(int fd, const off_t start_offset, +inline size_t WritePayload(int fd, + const off_t start_offset, const off_t end_offset) { return WritePayload(fd, start_offset, end_offset, 'a', 10); } @@ -279,17 +284,19 @@ inline size_t WritePayload(int fd, const off_t start_offset, // Send an empty response, then kill the server. void HandleQuit(int fd) { WriteHeaders(fd, 0, 0, kHttpResponseOk); - LOG(INFO) << "pid(" << getpid() << "): HTTP server exiting ..."; + LOG(INFO) << "pid(" << getpid() << "): HTTP server exiting ..."; exit(RC_OK); } - // Generates an HTTP response with payload corresponding to requested offsets // and length. Optionally, truncate the payload at a given length and add a // pause midway through the transfer. Returns the total number of bytes // delivered or -1 for error. -ssize_t HandleGet(int fd, const HttpRequest& request, const size_t total_length, - const size_t truncate_length, const int sleep_every, +ssize_t HandleGet(int fd, + const HttpRequest& request, + const size_t total_length, + const size_t truncate_length, + const int sleep_every, const int sleep_secs) { ssize_t ret; size_t written = 0; @@ -301,14 +308,14 @@ ssize_t HandleGet(int fd, const HttpRequest& request, const size_t total_length, << ") exceeds total length (" << total_length << "), generating error response (" << kHttpResponseReqRangeNotSat << ")"; - return WriteHeaders(fd, total_length, total_length, - kHttpResponseReqRangeNotSat); + return WriteHeaders( + fd, total_length, total_length, kHttpResponseReqRangeNotSat); } // Obtain end offset, adjust to fit in total payload length and ensure it does // not preceded the start offset. - size_t end_offset = (request.end_offset > 0 ? - request.end_offset : total_length); + size_t end_offset = + (request.end_offset > 0 ? request.end_offset : total_length); if (end_offset < start_offset) { LOG(WARNING) << "end offset (" << end_offset << ") precedes start offset (" << start_offset << "), generating error response"; @@ -324,8 +331,8 @@ ssize_t HandleGet(int fd, const HttpRequest& request, const size_t total_length, LOG(INFO) << "generating response header: range=" << start_offset << "-" << (end_offset - 1) << "/" << (end_offset - start_offset) << ", return code=" << request.return_code; - if ((ret = WriteHeaders(fd, start_offset, end_offset, - request.return_code)) < 0) + if ((ret = WriteHeaders(fd, start_offset, end_offset, request.return_code)) < + 0) return -1; LOG(INFO) << ret << " header bytes written"; written += ret; @@ -371,7 +378,8 @@ ssize_t HandleGet(int fd, const HttpRequest& request, const size_t total_length, return written; } -ssize_t HandleGet(int fd, const HttpRequest& request, +ssize_t HandleGet(int fd, + const HttpRequest& request, const size_t total_length) { return HandleGet(fd, request, total_length, 0, 0, 0); } @@ -388,15 +396,15 @@ void HandleRedirect(int fd, const HttpRequest& request) { HttpResponseCode code = StringToHttpResponseCode(url.c_str()); url.erase(0, url_start); url = "http://" + request.host + url; - const char *status = GetHttpResponseDescription(code); + const char* status = GetHttpResponseDescription(code); if (!status) CHECK(false) << "Unrecognized redirection code: " << code; LOG(INFO) << "Code: " << code << " " << status; LOG(INFO) << "New URL: " << url; ssize_t ret; - if ((ret = WriteString(fd, "HTTP/1.1 " + Itoa(code) + " " + - status + EOL)) < 0) + if ((ret = WriteString(fd, "HTTP/1.1 " + Itoa(code) + " " + status + EOL)) < + 0) return; WriteString(fd, "Location: " + url + EOL); } @@ -425,8 +433,10 @@ ssize_t HandleError(int fd, const HttpRequest& request) { // Generate an error response if the requested offset is nonzero, up to a given // maximal number of successive failures. The error generated is an "Internal // Server Error" (500). -ssize_t HandleErrorIfOffset(int fd, const HttpRequest& request, - size_t end_offset, int max_fails) { +ssize_t HandleErrorIfOffset(int fd, + const HttpRequest& request, + size_t end_offset, + int max_fails) { static int num_fails = 0; if (request.start_offset > 0 && num_fails < max_fails) { @@ -437,8 +447,8 @@ ssize_t HandleErrorIfOffset(int fd, const HttpRequest& request, const string data("This is an error page."); - if ((ret = WriteHeaders(fd, 0, data.size(), - kHttpResponseInternalServerError)) < 0) + if ((ret = WriteHeaders( + fd, 0, data.size(), kHttpResponseInternalServerError)) < 0) return -1; written += ret; @@ -464,7 +474,8 @@ void HandleEchoHeaders(int fd, const HttpRequest& request) { void HandleHang(int fd) { LOG(INFO) << "Hanging until the other side of the connection is closed."; char c; - while (HANDLE_EINTR(read(fd, &c, 1)) > 0) {} + while (HANDLE_EINTR(read(fd, &c, 1)) > 0) { + } } void HandleDefault(int fd, const HttpRequest& request) { @@ -475,36 +486,33 @@ void HandleDefault(int fd, const HttpRequest& request) { if ((ret = WriteHeaders(fd, start_offset, size, request.return_code)) < 0) return; - WriteString(fd, (start_offset < static_cast<off_t>(size) ? - data.substr(start_offset) : "")); + WriteString( + fd, + (start_offset < static_cast<off_t>(size) ? data.substr(start_offset) + : "")); } - // Break a URL into terms delimited by slashes. class UrlTerms { public: - UrlTerms(const string &url, size_t num_terms) { + UrlTerms(const string& url, size_t num_terms) { // URL must be non-empty and start with a slash. CHECK_GT(url.size(), static_cast<size_t>(0)); CHECK_EQ(url[0], '/'); // Split it into terms delimited by slashes, omitting the preceding slash. - terms = base::SplitString(url.substr(1), "/", base::KEEP_WHITESPACE, - base::SPLIT_WANT_ALL); + terms = base::SplitString( + url.substr(1), "/", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL); // Ensure expected length. CHECK_EQ(terms.size(), num_terms); } - inline const string& Get(const off_t index) const { - return terms[index]; - } - inline const char *GetCStr(const off_t index) const { + inline const string& Get(const off_t index) const { return terms[index]; } + inline const char* GetCStr(const off_t index) const { return Get(index).c_str(); } - inline int GetInt(const off_t index) const { - return atoi(GetCStr(index)); - } + inline int GetInt(const off_t index) const { return atoi(GetCStr(index)); } inline size_t GetSizeT(const off_t index) const { return static_cast<size_t>(atol(GetCStr(index))); } @@ -517,8 +525,8 @@ void HandleConnection(int fd) { HttpRequest request; ParseRequest(fd, &request); - string &url = request.url; - LOG(INFO) << "pid(" << getpid() << "): handling url " << url; + string& url = request.url; + LOG(INFO) << "pid(" << getpid() << "): handling url " << url; if (url == "/quitquitquit") { HandleQuit(fd); } else if (base::StartsWith( @@ -527,14 +535,18 @@ void HandleConnection(int fd) { HandleGet(fd, request, terms.GetSizeT(1)); } else if (base::StartsWith(url, "/flaky/", base::CompareCase::SENSITIVE)) { const UrlTerms terms(url, 5); - HandleGet(fd, request, terms.GetSizeT(1), terms.GetSizeT(2), - terms.GetInt(3), terms.GetInt(4)); + HandleGet(fd, + request, + terms.GetSizeT(1), + terms.GetSizeT(2), + terms.GetInt(3), + terms.GetInt(4)); } else if (url.find("/redirect/") == 0) { HandleRedirect(fd, request); } else if (url == "/error") { HandleError(fd, request); - } else if (base::StartsWith(url, "/error-if-offset/", - base::CompareCase::SENSITIVE)) { + } else if (base::StartsWith( + url, "/error-if-offset/", base::CompareCase::SENSITIVE)) { const UrlTerms terms(url, 3); HandleErrorIfOffset(fd, request, terms.GetSizeT(1), terms.GetInt(2)); } else if (url == "/echo-headers") { @@ -552,15 +564,14 @@ void HandleConnection(int fd) { using namespace chromeos_update_engine; // NOLINT(build/namespaces) - -void usage(const char *prog_arg) { - fprintf( - stderr, - "Usage: %s [ FILE ]\n" - "Once accepting connections, the following is written to FILE (or " - "stdout):\n" - "\"%sN\" (where N is an integer port number)\n", - basename(prog_arg), kListeningMsgPrefix); +void usage(const char* prog_arg) { + fprintf(stderr, + "Usage: %s [ FILE ]\n" + "Once accepting connections, the following is written to FILE (or " + "stdout):\n" + "\"%sN\" (where N is an integer port number)\n", + basename(prog_arg), + kListeningMsgPrefix); } int main(int argc, char** argv) { @@ -594,15 +605,16 @@ int main(int argc, char** argv) { { // Get rid of "Address in use" error int tr = 1; - if (setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &tr, - sizeof(int)) == -1) { + if (setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &tr, sizeof(int)) == + -1) { perror("setsockopt"); exit(RC_ERR_SETSOCKOPT); } } // Bind the socket and set for listening. - if (bind(listen_fd, reinterpret_cast<struct sockaddr *>(&server_addr), + if (bind(listen_fd, + reinterpret_cast<struct sockaddr*>(&server_addr), sizeof(server_addr)) < 0) { perror("bind"); exit(RC_ERR_BIND); @@ -615,7 +627,8 @@ int main(int argc, char** argv) { // Check the actual port. struct sockaddr_in bound_addr = sockaddr_in(); socklen_t bound_addr_len = sizeof(bound_addr); - if (getsockname(listen_fd, reinterpret_cast<struct sockaddr*>(&bound_addr), + if (getsockname(listen_fd, + reinterpret_cast<struct sockaddr*>(&bound_addr), &bound_addr_len) < 0) { perror("getsockname"); exit(RC_ERR_GETSOCKNAME); @@ -638,7 +651,7 @@ int main(int argc, char** argv) { close(report_fd); while (1) { - LOG(INFO) << "pid(" << getpid() << "): waiting to accept new connection"; + LOG(INFO) << "pid(" << getpid() << "): waiting to accept new connection"; int client_fd = accept(listen_fd, nullptr, nullptr); LOG(INFO) << "got past accept"; if (client_fd < 0) diff --git a/testrunner.cc b/testrunner.cc index 81d45487..db0b347a 100644 --- a/testrunner.cc +++ b/testrunner.cc @@ -26,7 +26,7 @@ #include "update_engine/common/terminator.h" #include "update_engine/payload_generator/xz.h" -int main(int argc, char **argv) { +int main(int argc, char** argv) { LOG(INFO) << "started"; base::AtExitManager exit_manager; // xz-embedded requires to initialize its CRC-32 table once on startup. diff --git a/update_attempter.cc b/update_attempter.cc index 5f323126..ee571db6 100644 --- a/update_attempter.cc +++ b/update_attempter.cc @@ -72,11 +72,11 @@ using base::Time; using base::TimeDelta; using base::TimeTicks; using brillo::MessageLoop; +using chromeos_update_manager::CalculateStagingCase; using chromeos_update_manager::EvalStatus; using chromeos_update_manager::Policy; -using chromeos_update_manager::UpdateCheckParams; -using chromeos_update_manager::CalculateStagingCase; using chromeos_update_manager::StagingCase; +using chromeos_update_manager::UpdateCheckParams; using std::string; using std::vector; using update_engine::UpdateAttemptFlags; @@ -100,10 +100,6 @@ const char kAUTestURLRequest[] = "autest"; const char kScheduledAUTestURLRequest[] = "autest-scheduled"; } // namespace -// Turns a generic ErrorCode::kError to a generic error code specific -// to |action| (e.g., ErrorCode::kFilesystemVerifierError). If |code| is -// not ErrorCode::kError, or the action is not matched, returns |code| -// unchanged. ErrorCode GetErrorCodeForAction(AbstractAction* action, ErrorCode code) { if (code != ErrorCode::kError) return code; @@ -162,8 +158,8 @@ bool UpdateAttempter::ScheduleUpdates() { chromeos_update_manager::UpdateManager* const update_manager = system_state_->update_manager(); CHECK(update_manager); - Callback<void(EvalStatus, const UpdateCheckParams&)> callback = Bind( - &UpdateAttempter::OnUpdateScheduled, base::Unretained(this)); + Callback<void(EvalStatus, const UpdateCheckParams&)> callback = + Bind(&UpdateAttempter::OnUpdateScheduled, base::Unretained(this)); // We limit the async policy request to a reasonably short time, to avoid a // starvation due to a transient bug. update_manager->AsyncPolicyRequest(callback, &Policy::UpdateCheckAllowed); @@ -193,7 +189,7 @@ bool UpdateAttempter::CheckAndReportDailyMetrics() { << "is wrong."; // In this case, report daily metrics to reset. } else { - if (time_reported_since.InSeconds() < 24*60*60) { + if (time_reported_since.InSeconds() < 24 * 60 * 60) { LOG(INFO) << "Last reported daily metrics " << utils::FormatTimeDelta(time_reported_since) << " ago."; return false; @@ -388,9 +384,7 @@ bool UpdateAttempter::CalculateUpdateParams(const string& app_version, } } - if (!omaha_request_params_->Init(app_version, - omaha_url, - interactive)) { + if (!omaha_request_params_->Init(app_version, omaha_url, interactive)) { LOG(ERROR) << "Unable to initialize Omaha request params."; return false; } @@ -403,8 +397,8 @@ bool UpdateAttempter::CalculateUpdateParams(const string& app_version, // Pass in false for powerwash_allowed until we add it to the policy // protobuf. string error_message; - if (!omaha_request_params_->SetTargetChannel(target_channel, false, - &error_message)) { + if (!omaha_request_params_->SetTargetChannel( + target_channel, false, &error_message)) { LOG(ERROR) << "Setting the channel failed: " << error_message; } @@ -430,8 +424,9 @@ bool UpdateAttempter::CalculateUpdateParams(const string& app_version, << omaha_request_params_->wall_clock_based_wait_enabled() << ", Update Check Count Wait Enabled = " << omaha_request_params_->update_check_count_wait_enabled() - << ", Waiting Period = " << utils::FormatSecs( - omaha_request_params_->waiting_period().InSeconds()); + << ", Waiting Period = " + << utils::FormatSecs( + omaha_request_params_->waiting_period().InSeconds()); LOG(INFO) << "Use p2p For Downloading = " << payload_state->GetUsingP2PForDownloading() @@ -451,9 +446,9 @@ bool UpdateAttempter::CalculateUpdateParams(const string& app_version, } else if (base::RandInt(0, 4) == 0) { obeying_proxies_ = false; } - LOG_IF(INFO, !obeying_proxies_) << "To help ensure updates work, this update " - "check we are ignoring the proxy settings and using " - "direct connections."; + LOG_IF(INFO, !obeying_proxies_) + << "To help ensure updates work, this update check we are ignoring the " + << "proxy settings and using direct connections."; DisableDeltaUpdateIfNeeded(); return true; @@ -468,7 +463,7 @@ void UpdateAttempter::CalculateScatteringParams(bool interactive) { int64_t new_scatter_factor_in_secs = 0; device_policy->GetScatterFactorInSeconds(&new_scatter_factor_in_secs); if (new_scatter_factor_in_secs < 0) // sanitize input, just in case. - new_scatter_factor_in_secs = 0; + new_scatter_factor_in_secs = 0; scatter_factor_ = TimeDelta::FromSeconds(new_scatter_factor_in_secs); } @@ -509,10 +504,10 @@ void UpdateAttempter::CalculateScatteringParams(bool interactive) { // generating a new random value to improve the chances of a good // distribution for scattering. omaha_request_params_->set_waiting_period( - TimeDelta::FromSeconds(wait_period_in_secs)); - LOG(INFO) << "Using persisted wall-clock waiting period: " << - utils::FormatSecs( - omaha_request_params_->waiting_period().InSeconds()); + TimeDelta::FromSeconds(wait_period_in_secs)); + LOG(INFO) << "Using persisted wall-clock waiting period: " + << utils::FormatSecs( + omaha_request_params_->waiting_period().InSeconds()); } else { // This means there's no persisted value for the waiting period // available or its value is invalid given the new scatter_factor value. @@ -532,9 +527,9 @@ void UpdateAttempter::CalculateScatteringParams(bool interactive) { } else { // Neither the first time scattering is enabled nor the scattering value // changed. Nothing to do. - LOG(INFO) << "Keeping current wall-clock waiting period: " << - utils::FormatSecs( - omaha_request_params_->waiting_period().InSeconds()); + LOG(INFO) << "Keeping current wall-clock waiting period: " + << utils::FormatSecs( + omaha_request_params_->waiting_period().InSeconds()); } // The invariant at this point is that omaha_request_params_->waiting_period @@ -550,7 +545,7 @@ void UpdateAttempter::CalculateScatteringParams(bool interactive) { // the update check count value, we'll turn that on as well. bool decrement_succeeded = DecrementUpdateCheckCount(); omaha_request_params_->set_update_check_count_wait_enabled( - decrement_succeeded); + decrement_succeeded); } else { // This means the scattering feature is turned off or disabled for // this particular update check. Make sure to disable @@ -569,11 +564,12 @@ void UpdateAttempter::CalculateScatteringParams(bool interactive) { } void UpdateAttempter::GenerateNewWaitingPeriod() { - omaha_request_params_->set_waiting_period(TimeDelta::FromSeconds( - base::RandInt(1, scatter_factor_.InSeconds()))); + omaha_request_params_->set_waiting_period( + TimeDelta::FromSeconds(base::RandInt(1, scatter_factor_.InSeconds()))); - LOG(INFO) << "Generated new wall-clock waiting period: " << utils::FormatSecs( - omaha_request_params_->waiting_period().InSeconds()); + LOG(INFO) << "Generated new wall-clock waiting period: " + << utils::FormatSecs( + omaha_request_params_->waiting_period().InSeconds()); // Do a best-effort to persist this in all cases. Even if the persistence // fails, we'll still be able to scatter based on our in-memory value. @@ -1013,7 +1009,7 @@ void UpdateAttempter::ProcessingDone(const ActionProcessor* processor, return; } LOG(INFO) << "Booted from FW B and tried to install new firmware, " - "so requesting reboot from user."; + "so requesting reboot from user."; } attempt_error_code_ = utils::GetBaseErrorCode(code); @@ -1267,7 +1263,7 @@ bool UpdateAttempter::ResetStatus() { // no-op. return true; - case UpdateStatus::UPDATED_NEED_REBOOT: { + case UpdateStatus::UPDATED_NEED_REBOOT: { bool ret_value = true; status_ = UpdateStatus::IDLE; @@ -1285,7 +1281,7 @@ bool UpdateAttempter::ResetStatus() { // Mark the current slot as successful again, since marking it as active // may reset the successful bit. We ignore the result of whether marking // the current slot as successful worked. - if (!boot_control->MarkBootSuccessfulAsync(Bind([](bool successful){}))) + if (!boot_control->MarkBootSuccessfulAsync(Bind([](bool successful) {}))) ret_value = false; // Notify the PayloadState that the successful payload was canceled. @@ -1330,7 +1326,7 @@ void UpdateAttempter::BroadcastStatus() { last_notify_time_ = TimeTicks::Now(); } -uint32_t UpdateAttempter::GetErrorCodeFlags() { +uint32_t UpdateAttempter::GetErrorCodeFlags() { uint32_t flags = 0; if (!system_state_->hardware()->IsNormalBootMode()) @@ -1399,11 +1395,10 @@ void UpdateAttempter::CreatePendingErrorEvent(AbstractAction* action, fake_update_success_ = code == ErrorCode::kPostinstallBootedFromFirmwareB; // Compute the final error code with all the bit flags to be sent to Omaha. - code = static_cast<ErrorCode>( - static_cast<uint32_t>(code) | GetErrorCodeFlags()); - error_event_.reset(new OmahaEvent(OmahaEvent::kTypeUpdateComplete, - event_result, - code)); + code = + static_cast<ErrorCode>(static_cast<uint32_t>(code) | GetErrorCodeFlags()); + error_event_.reset( + new OmahaEvent(OmahaEvent::kTypeUpdateComplete, event_result, code)); } bool UpdateAttempter::ScheduleErrorEventAction() { @@ -1497,7 +1492,6 @@ void UpdateAttempter::PingOmaha() { ScheduleUpdates(); } - bool UpdateAttempter::DecrementUpdateCheckCount() { int64_t update_check_count_value; @@ -1546,7 +1540,6 @@ bool UpdateAttempter::DecrementUpdateCheckCount() { return false; } - void UpdateAttempter::UpdateEngineStarted() { // If we just booted into a new update, keep the previous OS version // in case we rebooted because of a crash of the old version, so we @@ -1607,7 +1600,7 @@ bool UpdateAttempter::StartP2PAndPerformHousekeeping() { return true; } -bool UpdateAttempter::GetBootTimeAtUpdate(Time *out_boot_time) { +bool UpdateAttempter::GetBootTimeAtUpdate(Time* out_boot_time) { // In case of an update_engine restart without a reboot, we stored the boot_id // when the update was completed by setting a pref, so we can check whether // the last update was on this boot or a previous one. diff --git a/update_attempter.h b/update_attempter.h index af62ba6b..c27f8a40 100644 --- a/update_attempter.h +++ b/update_attempter.h @@ -186,7 +186,7 @@ class UpdateAttempter : public ActionProcessorDelegate, // Stores in |out_boot_time| the boottime (CLOCK_BOOTTIME) recorded at the // time of the last successful update in the current boot. Returns false if // there wasn't a successful update in the current boot. - virtual bool GetBootTimeAtUpdate(base::Time *out_boot_time); + virtual bool GetBootTimeAtUpdate(base::Time* out_boot_time); // Returns a version OS version that was being used before the last reboot, // and if that reboot happened to be into an update (current version). @@ -521,6 +521,13 @@ class UpdateAttempter : public ActionProcessorDelegate, DISALLOW_COPY_AND_ASSIGN(UpdateAttempter); }; +// Turns a generic ErrorCode::kError to a generic error code specific +// to |action| (e.g., ErrorCode::kFilesystemVerifierError). If |code| is +// not ErrorCode::kError, or the action is not matched, returns |code| +// unchanged. + +ErrorCode GetErrorCodeForAction(AbstractAction* action, ErrorCode code); + } // namespace chromeos_update_engine #endif // UPDATE_ENGINE_UPDATE_ATTEMPTER_H_ diff --git a/update_attempter_android.cc b/update_attempter_android.cc index a3974ab3..c738e4ef 100644 --- a/update_attempter_android.cc +++ b/update_attempter_android.cc @@ -317,7 +317,7 @@ bool UpdateAttempterAndroid::ResetStatus(brillo::ErrorPtr* error) { case UpdateStatus::IDLE: return true; - case UpdateStatus::UPDATED_NEED_REBOOT: { + case UpdateStatus::UPDATED_NEED_REBOOT: { // Remove the reboot marker so that if the machine is rebooted // after resetting to idle state, it doesn't go back to // UpdateStatus::UPDATED_NEED_REBOOT state. @@ -331,14 +331,12 @@ bool UpdateAttempterAndroid::ResetStatus(brillo::ErrorPtr* error) { // Mark the current slot as successful again, since marking it as active // may reset the successful bit. We ignore the result of whether marking // the current slot as successful worked. - if (!boot_control_->MarkBootSuccessfulAsync(Bind([](bool successful){}))) + if (!boot_control_->MarkBootSuccessfulAsync(Bind([](bool successful) {}))) ret_value = false; if (!ret_value) { return LogAndSetError( - error, - FROM_HERE, - "Failed to reset the status to "); + error, FROM_HERE, "Failed to reset the status to "); } SetStatusAndNotify(UpdateStatus::IDLE); diff --git a/update_attempter_unittest.cc b/update_attempter_unittest.cc index 3209f15f..579c7368 100644 --- a/update_attempter_unittest.cc +++ b/update_attempter_unittest.cc @@ -201,9 +201,7 @@ class UpdateAttempterTest : public ::testing::Test { bool actual_using_p2p_for_downloading() { return actual_using_p2p_for_downloading_; } - bool actual_using_p2p_for_sharing() { - return actual_using_p2p_for_sharing_; - } + bool actual_using_p2p_for_sharing() { return actual_using_p2p_for_sharing_; } base::MessageLoopForIO base_loop_; brillo::BaseMessageLoop loop_{&base_loop_}; @@ -338,8 +336,8 @@ TEST_F(UpdateAttempterTest, BroadcastCompleteDownloadTest) { TEST_F(UpdateAttempterTest, ActionCompletedOmahaRequestTest) { unique_ptr<MockHttpFetcher> fetcher(new MockHttpFetcher("", 0, nullptr)); fetcher->FailTransfer(500); // Sets the HTTP response code. - OmahaRequestAction action(&fake_system_state_, nullptr, - std::move(fetcher), false); + OmahaRequestAction action( + &fake_system_state_, nullptr, std::move(fetcher), false); ObjectCollectorAction<OmahaResponse> collector_action; BondActions(&action, &collector_action); OmahaResponse response; @@ -364,29 +362,27 @@ TEST_F(UpdateAttempterTest, ConstructWithUpdatedMarkerTest) { } TEST_F(UpdateAttempterTest, GetErrorCodeForActionTest) { - extern ErrorCode GetErrorCodeForAction(AbstractAction* action, - ErrorCode code); EXPECT_EQ(ErrorCode::kSuccess, GetErrorCodeForAction(nullptr, ErrorCode::kSuccess)); FakeSystemState fake_system_state; - OmahaRequestAction omaha_request_action(&fake_system_state, nullptr, - nullptr, false); + OmahaRequestAction omaha_request_action( + &fake_system_state, nullptr, nullptr, false); EXPECT_EQ(ErrorCode::kOmahaRequestError, GetErrorCodeForAction(&omaha_request_action, ErrorCode::kError)); OmahaResponseHandlerAction omaha_response_handler_action(&fake_system_state_); - EXPECT_EQ(ErrorCode::kOmahaResponseHandlerError, - GetErrorCodeForAction(&omaha_response_handler_action, - ErrorCode::kError)); + EXPECT_EQ( + ErrorCode::kOmahaResponseHandlerError, + GetErrorCodeForAction(&omaha_response_handler_action, ErrorCode::kError)); FilesystemVerifierAction filesystem_verifier_action; - EXPECT_EQ(ErrorCode::kFilesystemVerifierError, - GetErrorCodeForAction(&filesystem_verifier_action, - ErrorCode::kError)); + EXPECT_EQ( + ErrorCode::kFilesystemVerifierError, + GetErrorCodeForAction(&filesystem_verifier_action, ErrorCode::kError)); PostinstallRunnerAction postinstall_runner_action( fake_system_state.fake_boot_control(), fake_system_state.fake_hardware()); - EXPECT_EQ(ErrorCode::kPostinstallRunnerError, - GetErrorCodeForAction(&postinstall_runner_action, - ErrorCode::kError)); + EXPECT_EQ( + ErrorCode::kPostinstallRunnerError, + GetErrorCodeForAction(&postinstall_runner_action, ErrorCode::kError)); MockAction action_mock; EXPECT_CALL(action_mock, Type()).WillOnce(Return("MockAction")); EXPECT_EQ(ErrorCode::kError, @@ -400,15 +396,15 @@ TEST_F(UpdateAttempterTest, DisableDeltaUpdateIfNeededTest) { attempter_.DisableDeltaUpdateIfNeeded(); EXPECT_TRUE(attempter_.omaha_request_params_->delta_okay()); EXPECT_CALL(*prefs_, GetInt64(kPrefsDeltaUpdateFailures, _)) - .WillOnce(DoAll( - SetArgPointee<1>(UpdateAttempter::kMaxDeltaUpdateFailures - 1), - Return(true))); + .WillOnce( + DoAll(SetArgPointee<1>(UpdateAttempter::kMaxDeltaUpdateFailures - 1), + Return(true))); attempter_.DisableDeltaUpdateIfNeeded(); EXPECT_TRUE(attempter_.omaha_request_params_->delta_okay()); EXPECT_CALL(*prefs_, GetInt64(kPrefsDeltaUpdateFailures, _)) - .WillOnce(DoAll( - SetArgPointee<1>(UpdateAttempter::kMaxDeltaUpdateFailures), - Return(true))); + .WillOnce( + DoAll(SetArgPointee<1>(UpdateAttempter::kMaxDeltaUpdateFailures), + Return(true))); attempter_.DisableDeltaUpdateIfNeeded(); EXPECT_FALSE(attempter_.omaha_request_params_->delta_okay()); EXPECT_CALL(*prefs_, GetInt64(_, _)).Times(0); @@ -421,16 +417,17 @@ TEST_F(UpdateAttempterTest, MarkDeltaUpdateFailureTest) { .WillOnce(Return(false)) .WillOnce(DoAll(SetArgPointee<1>(-1), Return(true))) .WillOnce(DoAll(SetArgPointee<1>(1), Return(true))) - .WillOnce(DoAll( - SetArgPointee<1>(UpdateAttempter::kMaxDeltaUpdateFailures), - Return(true))); + .WillOnce( + DoAll(SetArgPointee<1>(UpdateAttempter::kMaxDeltaUpdateFailures), + Return(true))); EXPECT_CALL(*prefs_, SetInt64(Ne(kPrefsDeltaUpdateFailures), _)) .WillRepeatedly(Return(true)); EXPECT_CALL(*prefs_, SetInt64(kPrefsDeltaUpdateFailures, 1)).Times(2); EXPECT_CALL(*prefs_, SetInt64(kPrefsDeltaUpdateFailures, 2)); - EXPECT_CALL(*prefs_, SetInt64(kPrefsDeltaUpdateFailures, - UpdateAttempter::kMaxDeltaUpdateFailures + 1)); - for (int i = 0; i < 4; i ++) + EXPECT_CALL(*prefs_, + SetInt64(kPrefsDeltaUpdateFailures, + UpdateAttempter::kMaxDeltaUpdateFailures + 1)); + for (int i = 0; i < 4; i++) attempter_.MarkDeltaUpdateFailure(); } @@ -456,9 +453,8 @@ TEST_F(UpdateAttempterTest, ScheduleErrorEventActionTest) { EXPECT_CALL(*processor_, StartProcessing()); ErrorCode err = ErrorCode::kError; EXPECT_CALL(*fake_system_state_.mock_payload_state(), UpdateFailed(err)); - attempter_.error_event_.reset(new OmahaEvent(OmahaEvent::kTypeUpdateComplete, - OmahaEvent::kResultError, - err)); + attempter_.error_event_.reset(new OmahaEvent( + OmahaEvent::kTypeUpdateComplete, OmahaEvent::kResultError, err)); attempter_.ScheduleErrorEventAction(); EXPECT_EQ(UpdateStatus::REPORTING_ERROR_EVENT, attempter_.status()); } @@ -477,9 +473,10 @@ const string kUpdateActionTypes[] = { // NOLINT(runtime/string) OmahaRequestAction::StaticType()}; // Actions that will be built as part of a user-initiated rollback. -const string kRollbackActionTypes[] = { // NOLINT(runtime/string) - InstallPlanAction::StaticType(), - PostinstallRunnerAction::StaticType(), +const string kRollbackActionTypes[] = { + // NOLINT(runtime/string) + InstallPlanAction::StaticType(), + PostinstallRunnerAction::StaticType(), }; const StagingSchedule kValidStagingSchedule = { @@ -494,7 +491,8 @@ void UpdateAttempterTest::UpdateTestStart() { // point by calling RefreshDevicePolicy. auto device_policy = std::make_unique<policy::MockDevicePolicy>(); EXPECT_CALL(*device_policy, LoadPolicy()) - .Times(testing::AtLeast(1)).WillRepeatedly(Return(true)); + .Times(testing::AtLeast(1)) + .WillRepeatedly(Return(true)); attempter_.policy_provider_.reset( new policy::PolicyProvider(std::move(device_policy))); @@ -521,22 +519,21 @@ void UpdateAttempterTest::UpdateTestVerify() { loop_.BreakLoop(); } -void UpdateAttempterTest::RollbackTestStart( - bool enterprise_rollback, bool valid_slot) { +void UpdateAttempterTest::RollbackTestStart(bool enterprise_rollback, + bool valid_slot) { // Create a device policy so that we can change settings. auto device_policy = std::make_unique<policy::MockDevicePolicy>(); EXPECT_CALL(*device_policy, LoadPolicy()).WillRepeatedly(Return(true)); fake_system_state_.set_device_policy(device_policy.get()); if (enterprise_rollback) { // We return an empty owner as this is an enterprise. - EXPECT_CALL(*device_policy, GetOwner(_)).WillRepeatedly( - DoAll(SetArgPointee<0>(string("")), - Return(true))); + EXPECT_CALL(*device_policy, GetOwner(_)) + .WillRepeatedly(DoAll(SetArgPointee<0>(string("")), Return(true))); } else { // We return a fake owner as this is an owned consumer device. - EXPECT_CALL(*device_policy, GetOwner(_)).WillRepeatedly( - DoAll(SetArgPointee<0>(string("fake.mail@fake.com")), - Return(true))); + EXPECT_CALL(*device_policy, GetOwner(_)) + .WillRepeatedly(DoAll(SetArgPointee<0>(string("fake.mail@fake.com")), + Return(true))); } attempter_.policy_provider_.reset( @@ -555,7 +552,7 @@ void UpdateAttempterTest::RollbackTestStart( // We only allow rollback on devices that are not enterprise enrolled and // which have a valid slot to rollback to. if (!enterprise_rollback && valid_slot) { - is_rollback_allowed = true; + is_rollback_allowed = true; } if (is_rollback_allowed) { @@ -595,7 +592,8 @@ TEST_F(UpdateAttempterTest, RollbackTest) { loop_.PostTask(FROM_HERE, base::Bind(&UpdateAttempterTest::RollbackTestStart, base::Unretained(this), - false, true)); + false, + true)); loop_.Run(); } @@ -603,7 +601,8 @@ TEST_F(UpdateAttempterTest, InvalidSlotRollbackTest) { loop_.PostTask(FROM_HERE, base::Bind(&UpdateAttempterTest::RollbackTestStart, base::Unretained(this), - false, false)); + false, + false)); loop_.Run(); } @@ -611,7 +610,8 @@ TEST_F(UpdateAttempterTest, EnterpriseRollbackTest) { loop_.PostTask(FROM_HERE, base::Bind(&UpdateAttempterTest::RollbackTestStart, base::Unretained(this), - true, true)); + true, + true)); loop_.Run(); } @@ -661,10 +661,9 @@ TEST_F(UpdateAttempterTest, CreatePendingErrorEventResumedTest) { EXPECT_EQ(OmahaEvent::kTypeUpdateComplete, attempter_.error_event_->type); EXPECT_EQ(OmahaEvent::kResultError, attempter_.error_event_->result); EXPECT_EQ( - static_cast<ErrorCode>( - static_cast<int>(kCode) | - static_cast<int>(ErrorCode::kResumedFlag) | - static_cast<int>(ErrorCode::kTestOmahaUrlFlag)), + static_cast<ErrorCode>(static_cast<int>(kCode) | + static_cast<int>(ErrorCode::kResumedFlag) | + static_cast<int>(ErrorCode::kTestOmahaUrlFlag)), attempter_.error_event_->error_code); } @@ -827,9 +826,8 @@ void UpdateAttempterTest::ReadScatterFactorFromPolicyTestStart() { fake_system_state_.set_device_policy(device_policy.get()); EXPECT_CALL(*device_policy, GetScatterFactorInSeconds(_)) - .WillRepeatedly(DoAll( - SetArgPointee<0>(scatter_factor_in_seconds), - Return(true))); + .WillRepeatedly( + DoAll(SetArgPointee<0>(scatter_factor_in_seconds), Return(true))); attempter_.policy_provider_.reset( new policy::PolicyProvider(std::move(device_policy))); @@ -866,9 +864,8 @@ void UpdateAttempterTest::DecrementUpdateCheckCountTestStart() { fake_system_state_.set_device_policy(device_policy.get()); EXPECT_CALL(*device_policy, GetScatterFactorInSeconds(_)) - .WillRepeatedly(DoAll( - SetArgPointee<0>(scatter_factor_in_seconds), - Return(true))); + .WillRepeatedly( + DoAll(SetArgPointee<0>(scatter_factor_in_seconds), Return(true))); attempter_.policy_provider_.reset( new policy::PolicyProvider(std::move(device_policy))); @@ -898,9 +895,11 @@ void UpdateAttempterTest::DecrementUpdateCheckCountTestStart() { } TEST_F(UpdateAttempterTest, NoScatteringDoneDuringManualUpdateTestStart) { - loop_.PostTask(FROM_HERE, base::Bind( - &UpdateAttempterTest::NoScatteringDoneDuringManualUpdateTestStart, - base::Unretained(this))); + loop_.PostTask( + FROM_HERE, + base::Bind( + &UpdateAttempterTest::NoScatteringDoneDuringManualUpdateTestStart, + base::Unretained(this))); loop_.Run(); } @@ -927,9 +926,8 @@ void UpdateAttempterTest::NoScatteringDoneDuringManualUpdateTestStart() { fake_system_state_.set_device_policy(device_policy.get()); EXPECT_CALL(*device_policy, GetScatterFactorInSeconds(_)) - .WillRepeatedly(DoAll( - SetArgPointee<0>(scatter_factor_in_seconds), - Return(true))); + .WillRepeatedly( + DoAll(SetArgPointee<0>(scatter_factor_in_seconds), Return(true))); attempter_.policy_provider_.reset( new policy::PolicyProvider(std::move(device_policy))); diff --git a/update_engine_client.cc b/update_engine_client.cc index f36949b8..7446041c 100644 --- a/update_engine_client.cc +++ b/update_engine_client.cc @@ -61,15 +61,15 @@ const int kShowStatusRetryIntervalInSeconds = 2; class UpdateEngineClient : public brillo::Daemon { public: - UpdateEngineClient(int argc, char** argv) : argc_(argc), argv_(argv) { - } + UpdateEngineClient(int argc, char** argv) : argc_(argc), argv_(argv) {} ~UpdateEngineClient() override = default; protected: int OnInit() override { int ret = Daemon::OnInit(); - if (ret != EX_OK) return ret; + if (ret != EX_OK) + return ret; client_ = update_engine::UpdateEngineClient::CreateInstance(); @@ -140,8 +140,11 @@ class WatchingStatusUpdateHandler : public ExitingStatusUpdateHandler { }; void WatchingStatusUpdateHandler::HandleStatusUpdate( - int64_t last_checked_time, double progress, UpdateStatus current_operation, - const string& new_version, int64_t new_size) { + int64_t last_checked_time, + double progress, + UpdateStatus current_operation, + const string& new_version, + int64_t new_size) { LOG(INFO) << "Got status update:"; LOG(INFO) << " last_checked_time: " << last_checked_time; LOG(INFO) << " progress: " << progress; @@ -160,8 +163,11 @@ bool UpdateEngineClient::ShowStatus() { int retry_count = kShowStatusRetryCount; while (retry_count > 0) { - if (client_->GetStatus(&last_checked_time, &progress, ¤t_op, - &new_version, &new_size)) { + if (client_->GetStatus(&last_checked_time, + &progress, + ¤t_op, + &new_version, + &new_size)) { break; } if (--retry_count == 0) { @@ -175,8 +181,11 @@ bool UpdateEngineClient::ShowStatus() { printf("LAST_CHECKED_TIME=%" PRIi64 "\nPROGRESS=%f\nCURRENT_OP=%s\n" "NEW_VERSION=%s\nNEW_SIZE=%" PRIi64 "\n", - last_checked_time, progress, UpdateStatusToString(current_op), - new_version.c_str(), new_size); + last_checked_time, + progress, + UpdateStatusToString(current_op), + new_version.c_str(), + new_size); return true; } @@ -188,8 +197,11 @@ int UpdateEngineClient::GetNeedReboot() { string new_version; int64_t new_size = 0; - if (!client_->GetStatus(&last_checked_time, &progress, ¤t_op, - &new_version, &new_size)) { + if (!client_->GetStatus(&last_checked_time, + &progress, + ¤t_op, + &new_version, + &new_size)) { return 1; } @@ -244,54 +256,68 @@ void UpdateWaitHandler::HandleStatusUpdate(int64_t /* last_checked_time */, int UpdateEngineClient::ProcessFlags() { DEFINE_string(app_version, "", "Force the current app version."); - DEFINE_string(channel, "", + DEFINE_string(channel, + "", "Set the target channel. The device will be powerwashed if the " "target channel is more stable than the current channel unless " "--nopowerwash is specified."); DEFINE_bool(check_for_update, false, "Initiate check for updates."); DEFINE_string( cohort_hint, "", "Set the current cohort hint to the passed value."); - DEFINE_bool(follow, false, + DEFINE_bool(follow, + false, "Wait for any update operations to complete." "Exit status is 0 if the update succeeded, and 1 otherwise."); DEFINE_bool(interactive, true, "Mark the update request as interactive."); DEFINE_string(omaha_url, "", "The URL of the Omaha update server."); - DEFINE_string(p2p_update, "", + DEFINE_string(p2p_update, + "", "Enables (\"yes\") or disables (\"no\") the peer-to-peer update" " sharing."); - DEFINE_bool(powerwash, true, + DEFINE_bool(powerwash, + true, "When performing rollback or channel change, " "do a powerwash or allow it respectively."); DEFINE_bool(reboot, false, "Initiate a reboot if needed."); - DEFINE_bool(is_reboot_needed, false, + DEFINE_bool(is_reboot_needed, + false, "Exit status 0 if reboot is needed, " "2 if reboot is not needed or 1 if an error occurred."); - DEFINE_bool(block_until_reboot_is_needed, false, + DEFINE_bool(block_until_reboot_is_needed, + false, "Blocks until reboot is " "needed. Returns non-zero exit status if an error occurred."); DEFINE_bool(reset_status, false, "Sets the status in update_engine to idle."); - DEFINE_bool(rollback, false, + DEFINE_bool(rollback, + false, "Perform a rollback to the previous partition. The device will " "be powerwashed unless --nopowerwash is specified."); - DEFINE_bool(can_rollback, false, + DEFINE_bool(can_rollback, + false, "Shows whether rollback partition " "is available."); DEFINE_bool(show_channel, false, "Show the current and target channels."); DEFINE_bool(show_cohort_hint, false, "Show the current cohort hint."); - DEFINE_bool(show_p2p_update, false, + DEFINE_bool(show_p2p_update, + false, "Show the current setting for peer-to-peer update sharing."); - DEFINE_bool(show_update_over_cellular, false, + DEFINE_bool(show_update_over_cellular, + false, "Show the current setting for updates over cellular networks."); DEFINE_bool(status, false, "Print the status to stdout."); - DEFINE_bool(update, false, + DEFINE_bool(update, + false, "Forces an update and waits for it to complete. " "Implies --follow."); - DEFINE_string(update_over_cellular, "", + DEFINE_string(update_over_cellular, + "", "Enables (\"yes\") or disables (\"no\") the updates over " "cellular networks."); - DEFINE_bool(watch_for_updates, false, + DEFINE_bool(watch_for_updates, + false, "Listen for status updates and print them to the screen."); - DEFINE_bool(prev_version, false, + DEFINE_bool(prev_version, + false, "Show the previous OS version used before the update reboot."); DEFINE_bool(last_attempt_error, false, "Show the last attempt error."); DEFINE_bool(eol_status, false, "Show the current end-of-life status."); @@ -464,7 +490,8 @@ int UpdateEngineClient::ProcessFlags() { bool do_update_request = FLAGS_check_for_update || FLAGS_update || !FLAGS_app_version.empty() || !FLAGS_omaha_url.empty(); - if (FLAGS_update) FLAGS_follow = true; + if (FLAGS_update) + FLAGS_follow = true; if (do_update_request && FLAGS_rollback) { LOG(ERROR) << "Incompatible flags specified with rollback." @@ -513,8 +540,8 @@ int UpdateEngineClient::ProcessFlags() { LOG(INFO) << "Forcing an update by setting app_version to ForcedUpdate."; } LOG(INFO) << "Initiating update check and install."; - if (!client_->AttemptUpdate(app_version, FLAGS_omaha_url, - FLAGS_interactive)) { + if (!client_->AttemptUpdate( + app_version, FLAGS_omaha_url, FLAGS_interactive)) { LOG(ERROR) << "Error checking for update."; return 1; } diff --git a/update_engine_client_android.cc b/update_engine_client_android.cc index 82a9f841..6863799f 100644 --- a/update_engine_client_android.cc +++ b/update_engine_client_android.cc @@ -49,8 +49,7 @@ namespace internal { class UpdateEngineClientAndroid : public brillo::Daemon { public: - UpdateEngineClientAndroid(int argc, char** argv) : argc_(argc), argv_(argv) { - } + UpdateEngineClientAndroid(int argc, char** argv) : argc_(argc), argv_(argv) {} int ExitWhenIdle(const Status& status); int ExitWhenIdle(int return_code); @@ -83,8 +82,8 @@ class UpdateEngineClientAndroid : public brillo::Daemon { brillo::BinderWatcher binder_watcher_; }; -Status UpdateEngineClientAndroid::UECallback::onStatusUpdate( - int status_code, float progress) { +Status UpdateEngineClientAndroid::UECallback::onStatusUpdate(int status_code, + float progress) { update_engine::UpdateStatus status = static_cast<update_engine::UpdateStatus>(status_code); LOG(INFO) << "onStatusUpdate(" << UpdateStatusToString(status) << " (" @@ -113,10 +112,12 @@ int UpdateEngineClientAndroid::OnInit() { DEFINE_string(payload, "http://127.0.0.1:8080/payload", "The URI to the update payload to use."); - DEFINE_int64(offset, 0, + DEFINE_int64(offset, + 0, "The offset in the payload where the CrAU update starts. " "Used when --update is passed."); - DEFINE_int64(size, 0, + DEFINE_int64(size, + 0, "The size of the CrAU part of the payload. If 0 is passed, it " "will be autodetected. Used when --update is passed."); DEFINE_string(headers, @@ -264,7 +265,7 @@ void UpdateEngineClientAndroid::UpdateEngineServiceDied() { } // namespace chromeos_update_engine int main(int argc, char** argv) { - chromeos_update_engine::internal::UpdateEngineClientAndroid client( - argc, argv); + chromeos_update_engine::internal::UpdateEngineClientAndroid client(argc, + argv); return client.Run(); } diff --git a/update_status_utils.cc b/update_status_utils.cc index 5de3381f..cbc4f14b 100644 --- a/update_status_utils.cc +++ b/update_status_utils.cc @@ -52,8 +52,7 @@ const char* UpdateStatusToString(const UpdateStatus& status) { return nullptr; } -bool StringToUpdateStatus(const std::string& s, - UpdateStatus* status) { +bool StringToUpdateStatus(const std::string& s, UpdateStatus* status) { if (s == update_engine::kUpdateStatusIdle) { *status = UpdateStatus::IDLE; return true; |