libchromeos: Cleaned up code with clang-format
Ran clang-format to bring the source code formatting in libchromeos
closer to the official Chromium coding style.
BUG=None
TEST=FEATURES=test emerge-link libchromeos
Change-Id: I68cfcdd517711050e30ebfff7d848054df42d125
Reviewed-on: https://chromium-review.googlesource.com/240430
Trybot-Ready: Alex Vakulenko <avakulenko@chromium.org>
Tested-by: Alex Vakulenko <avakulenko@chromium.org>
Reviewed-by: Vitaly Buka <vitalybuka@chromium.org>
Reviewed-by: Christopher Wiley <wiley@chromium.org>
Commit-Queue: Alex Vakulenko <avakulenko@chromium.org>
diff --git a/chromeos/any.h b/chromeos/any.h
index bda7e60..fa09a13 100644
--- a/chromeos/any.h
+++ b/chromeos/any.h
@@ -112,11 +112,10 @@
// convertible to/compatible with it.
template<typename T>
const T& Get() const {
- CHECK(IsTypeCompatible<T>()) << "Requesting value of type '"
- << GetUndecoratedTypeName<T>()
- << "' from variant containing '"
- << UndecorateTypeName(GetType().name())
- << "'";
+ CHECK(IsTypeCompatible<T>())
+ << "Requesting value of type '" << GetUndecoratedTypeName<T>()
+ << "' from variant containing '" << UndecorateTypeName(GetType().name())
+ << "'";
return data_buffer_.GetData<T>();
}
@@ -193,4 +192,3 @@
} // namespace std
#endif // LIBCHROMEOS_CHROMEOS_ANY_H_
-
diff --git a/chromeos/any_internal_impl.h b/chromeos/any_internal_impl.h
index 13aef03..3944baa 100644
--- a/chromeos/any_internal_impl.h
+++ b/chromeos/any_internal_impl.h
@@ -22,10 +22,12 @@
// An extension to std::is_convertible to allow conversion from an enum to
// an integral type which std::is_convertible does not indicate as supported.
template <typename From, typename To>
-struct IsConvertible : public std::integral_constant<bool,
- std::is_convertible<From, To>::value ||
- (std::is_enum<From>::value && std::is_integral<To>::value)> {
-};
+struct IsConvertible
+ : public std::integral_constant<
+ bool,
+ std::is_convertible<From, To>::value ||
+ (std::is_enum<From>::value && std::is_integral<To>::value)> {};
+
// TryConvert is a helper function that does a safe compile-time conditional
// type cast between data types that may not be always convertible.
// From and To are the source and destination types.
@@ -101,7 +103,7 @@
// lvalue references to type U which is not necessarily default-constructible.
template<typename U>
static decltype((std::declval<U&>() == std::declval<U&>()), std::true_type())
- TriggerFunction(int dummy);
+ TriggerFunction(int dummy);
// Finally, use the return type of the overload of TriggerFunction that
// matches the argument (int) to be aliased to type |type|. If T is
@@ -117,18 +119,21 @@
// type is non-comparable. We just use |type| alias from
// IsEqualityComparableHelper<T> as the base class.
template<typename T>
-struct IsEqualityComparable : IsEqualityComparableHelper<T>::type {
-};
+struct IsEqualityComparable : IsEqualityComparableHelper<T>::type {};
// EqCompare() overload for non-comparable types. Always returns false.
template<typename T>
inline typename std::enable_if<!IsEqualityComparable<T>::value, bool>::type
- EqCompare(const T& v1, const T& v2) { return false; }
+EqCompare(const T& v1, const T& v2) {
+ return false;
+}
// EqCompare overload for comparable types. Calls operator==(v1, v2) to compare.
template<typename T>
inline typename std::enable_if<IsEqualityComparable<T>::value, bool>::type
- EqCompare(const T& v1, const T& v2) { return (v1 == v2); }
+EqCompare(const T& v1, const T& v2) {
+ return (v1 == v2);
+}
//////////////////////////////////////////////////////////////////////////////
@@ -170,8 +175,7 @@
intmax_t int_val = 0;
bool converted = TryConvert(value_, &int_val);
CHECK(converted) << "Unable to convert value of type '"
- << GetUndecoratedTypeName<T>()
- << "' to integer";
+ << GetUndecoratedTypeName<T>() << "' to integer";
return int_val;
}
@@ -216,17 +220,11 @@
public:
enum StorageType { kExternal, kContained };
Buffer() : external_ptr_(nullptr), storage_(kExternal) {}
- ~Buffer() {
- Clear();
- }
+ ~Buffer() { Clear(); }
- Buffer(const Buffer& rhs) : Buffer() {
- rhs.CopyTo(this);
- }
+ Buffer(const Buffer& rhs) : Buffer() { rhs.CopyTo(this); }
// NOLINTNEXTLINE(build/c++11)
- Buffer(Buffer&& rhs) : Buffer() {
- rhs.MoveTo(this);
- }
+ Buffer(Buffer&& rhs) : Buffer() { rhs.MoveTo(this); }
Buffer& operator=(const Buffer& rhs) {
rhs.CopyTo(this);
return *this;
@@ -240,12 +238,13 @@
// Returns the underlying pointer to contained data. Uses either the pointer
// or the raw data depending on |storage_| type.
inline Data* GetDataPtr() {
- return (storage_ == kExternal) ?
- external_ptr_ : reinterpret_cast<Data*>(contained_buffer_);
+ return (storage_ == kExternal) ? external_ptr_
+ : reinterpret_cast<Data*>(contained_buffer_);
}
inline const Data* GetDataPtr() const {
- return (storage_ == kExternal) ?
- external_ptr_ : reinterpret_cast<const Data*>(contained_buffer_);
+ return (storage_ == kExternal)
+ ? external_ptr_
+ : reinterpret_cast<const Data*>(contained_buffer_);
}
// Destroys the contained object (and frees memory if needed).
@@ -358,14 +357,17 @@
StorageType storage_; // Declare after the union to eliminate member padding.
};
-template<typename T>
-void TypedData<T>::CopyTo(Buffer* buffer) const { buffer->Assign(value_); }
-template<typename T>
-void TypedData<T>::MoveTo(Buffer* buffer) { buffer->Assign(std::move(value_)); }
+template <typename T>
+void TypedData<T>::CopyTo(Buffer* buffer) const {
+ buffer->Assign(value_);
+}
+template <typename T>
+void TypedData<T>::MoveTo(Buffer* buffer) {
+ buffer->Assign(std::move(value_));
+}
} // namespace internal_details
} // namespace chromeos
#endif // LIBCHROMEOS_CHROMEOS_ANY_INTERNAL_IMPL_H_
-
diff --git a/chromeos/any_unittest.cc b/chromeos/any_unittest.cc
index 289a0ef..a1114d9 100644
--- a/chromeos/any_unittest.cc
+++ b/chromeos/any_unittest.cc
@@ -304,4 +304,3 @@
EXPECT_NE(person1, person3);
EXPECT_NE(person2, person3);
}
-
diff --git a/chromeos/asynchronous_signal_handler.cc b/chromeos/asynchronous_signal_handler.cc
index 0e02956..5bb430d 100644
--- a/chromeos/asynchronous_signal_handler.cc
+++ b/chromeos/asynchronous_signal_handler.cc
@@ -45,7 +45,10 @@
signalfd(descriptor_, &signal_mask_, SFD_CLOEXEC | SFD_NONBLOCK);
CHECK_NE(kInvalidDescriptor, descriptor_);
CHECK(base::MessageLoopForIO::current()->WatchFileDescriptor(
- descriptor_, true, base::MessageLoopForIO::WATCH_READ, fd_watcher_.get(),
+ descriptor_,
+ true,
+ base::MessageLoopForIO::WATCH_READ,
+ fd_watcher_.get(),
this))
<< "Watching shutdown pipe failed.";
}
diff --git a/chromeos/asynchronous_signal_handler_unittest.cc b/chromeos/asynchronous_signal_handler_unittest.cc
index ca1c870..9c9055e 100644
--- a/chromeos/asynchronous_signal_handler_unittest.cc
+++ b/chromeos/asynchronous_signal_handler_unittest.cc
@@ -24,9 +24,7 @@
AsynchronousSignalHandlerTest() {}
virtual ~AsynchronousSignalHandlerTest() {}
- virtual void SetUp() {
- handler_.Init();
- }
+ virtual void SetUp() { handler_.Init(); }
virtual void TearDown() {}
@@ -53,8 +51,10 @@
TEST_F(AsynchronousSignalHandlerTest, CheckTerm) {
handler_.RegisterHandler(
- SIGTERM, base::Bind(&AsynchronousSignalHandlerTest::RecordInfoAndQuit,
- base::Unretained(this), true));
+ SIGTERM,
+ base::Bind(&AsynchronousSignalHandlerTest::RecordInfoAndQuit,
+ base::Unretained(this),
+ true));
EXPECT_EQ(0, infos_.size());
EXPECT_EQ(0, kill(getpid(), SIGTERM));
@@ -67,8 +67,10 @@
TEST_F(AsynchronousSignalHandlerTest, CheckSignalUnregistration) {
handler_.RegisterHandler(
- SIGCHLD, base::Bind(&AsynchronousSignalHandlerTest::RecordInfoAndQuit,
- base::Unretained(this), true));
+ SIGCHLD,
+ base::Bind(&AsynchronousSignalHandlerTest::RecordInfoAndQuit,
+ base::Unretained(this),
+ true));
EXPECT_EQ(0, infos_.size());
EXPECT_EQ(0, kill(getpid(), SIGCHLD));
@@ -81,7 +83,8 @@
EXPECT_EQ(0, kill(getpid(), SIGCHLD));
// Run the loop with a timeout, as no message are expected.
- loop_.PostDelayedTask(FROM_HERE, base::MessageLoop::QuitClosure(),
+ loop_.PostDelayedTask(FROM_HERE,
+ base::MessageLoop::QuitClosure(),
base::TimeDelta::FromMilliseconds(10));
Run();
@@ -93,8 +96,10 @@
TEST_F(AsynchronousSignalHandlerTest, CheckMultipleSignal) {
const uint8_t NB_SIGNALS = 5;
handler_.RegisterHandler(
- SIGCHLD, base::Bind(&AsynchronousSignalHandlerTest::RecordInfoAndQuit,
- base::Unretained(this), false));
+ SIGCHLD,
+ base::Bind(&AsynchronousSignalHandlerTest::RecordInfoAndQuit,
+ base::Unretained(this),
+ false));
EXPECT_EQ(0, infos_.size());
for (int i = 0; i < NB_SIGNALS; ++i) {
EXPECT_EQ(0, kill(getpid(), SIGCHLD));
@@ -111,8 +116,10 @@
TEST_F(AsynchronousSignalHandlerTest, CheckChld) {
handler_.RegisterHandler(
- SIGCHLD, base::Bind(&AsynchronousSignalHandlerTest::RecordInfoAndQuit,
- base::Unretained(this), false));
+ SIGCHLD,
+ base::Bind(&AsynchronousSignalHandlerTest::RecordInfoAndQuit,
+ base::Unretained(this),
+ false));
pid_t child_pid = fork();
if (child_pid == 0) {
_Exit(EXIT_SUCCESS);
diff --git a/chromeos/bind_lambda.h b/chromeos/bind_lambda.h
index ba1d748..27b4d4e 100644
--- a/chromeos/bind_lambda.h
+++ b/chromeos/bind_lambda.h
@@ -50,12 +50,11 @@
};
template <typename Lambda>
-class RunnableAdapter : public LambdaAdapter<Lambda,
- decltype(&Lambda::operator())> {
+class RunnableAdapter
+ : public LambdaAdapter<Lambda, decltype(&Lambda::operator())> {
public:
- explicit RunnableAdapter(Lambda lambda) :
- LambdaAdapter<Lambda, decltype(&Lambda::operator())>(lambda) {
- }
+ explicit RunnableAdapter(Lambda lambda)
+ : LambdaAdapter<Lambda, decltype(&Lambda::operator())>(lambda) {}
};
} // namespace internal
diff --git a/chromeos/bootstat/bootstat.h b/chromeos/bootstat/bootstat.h
index b1b8b4d..d568b38 100644
--- a/chromeos/bootstat/bootstat.h
+++ b/chromeos/bootstat/bootstat.h
@@ -24,7 +24,7 @@
// bootstat_log.c regarding implementation assumptions for this
// value.
//
-#define BOOTSTAT_MAX_EVENT_LEN 64
+#define BOOTSTAT_MAX_EVENT_LEN 64
// Log an event. Event names should be composed of characters drawn
// from this subset of 7-bit ASCII: Letters (upper- or lower-case),
diff --git a/chromeos/cryptohome.cc b/chromeos/cryptohome.cc
index b6189ae..f7f4f93 100644
--- a/chromeos/cryptohome.cc
+++ b/chromeos/cryptohome.cc
@@ -36,7 +36,7 @@
FilePath salt_path(g_system_salt_path);
int64_t file_size;
if (!base::GetFileSize(salt_path, &file_size)) {
- PLOG(ERROR) << "Could not get size of system salt: " << g_system_salt_path;
+ PLOG(ERROR) << "Could not get size of system salt: " << g_system_salt_path;
return false;
}
if (file_size > static_cast<int64_t>(std::numeric_limits<int>::max())) {
@@ -47,8 +47,8 @@
buf.resize(file_size);
unsigned int data_read = base::ReadFile(salt_path, &buf.front(), file_size);
if (data_read != file_size) {
- PLOG(ERROR) << "Could not read entire file: " << data_read << " != "
- << file_size;
+ PLOG(ERROR) << "Could not read entire file: " << data_read
+ << " != " << file_size;
return false;
}
@@ -64,8 +64,8 @@
unsigned char binmd[SHA_DIGEST_LENGTH];
std::string lowercase(username);
- std::transform(lowercase.begin(), lowercase.end(),
- lowercase.begin(), ::tolower);
+ std::transform(
+ lowercase.begin(), lowercase.end(), lowercase.begin(), ::tolower);
SHA_CTX ctx;
SHA1_Init(&ctx);
SHA1_Update(&ctx, salt->data(), salt->size());
@@ -86,8 +86,8 @@
}
FilePath GetHashedUserPath(const std::string& hashed_username) {
- return FilePath(base::StringPrintf("%s%s", g_user_home_prefix,
- hashed_username.c_str()));
+ return FilePath(
+ base::StringPrintf("%s%s", g_user_home_prefix, hashed_username.c_str()));
}
FilePath GetUserPath(const std::string& username) {
@@ -99,8 +99,8 @@
FilePath GetRootPath(const std::string& username) {
if (!EnsureSystemSaltIsLoaded())
return FilePath("");
- return FilePath(base::StringPrintf("%s%s", g_root_home_prefix,
- SanitizeUserName(username).c_str()));
+ return FilePath(base::StringPrintf(
+ "%s%s", g_root_home_prefix, SanitizeUserName(username).c_str()));
}
FilePath GetDaemonPath(const std::string& username, const std::string& daemon) {
@@ -112,24 +112,20 @@
bool IsSanitizedUserName(const std::string& sanitized) {
std::vector<uint8_t> bytes;
return (sanitized.length() == 2 * SHA_DIGEST_LENGTH) &&
- base::HexStringToBytes(sanitized, &bytes);
+ base::HexStringToBytes(sanitized, &bytes);
}
void SetUserHomePrefix(const std::string& prefix) {
if (prefix.length() < sizeof(g_user_home_prefix)) {
- snprintf(g_user_home_prefix,
- sizeof(g_user_home_prefix),
- "%s",
- prefix.c_str());
+ snprintf(
+ g_user_home_prefix, sizeof(g_user_home_prefix), "%s", prefix.c_str());
}
}
void SetRootHomePrefix(const std::string& prefix) {
if (prefix.length() < sizeof(g_root_home_prefix)) {
- snprintf(g_root_home_prefix,
- sizeof(g_root_home_prefix),
- "%s",
- prefix.c_str());
+ snprintf(
+ g_root_home_prefix, sizeof(g_root_home_prefix), "%s", prefix.c_str());
}
}
diff --git a/chromeos/daemons/dbus_daemon.cc b/chromeos/daemons/dbus_daemon.cc
index c6cb986..f343746 100644
--- a/chromeos/daemons/dbus_daemon.cc
+++ b/chromeos/daemons/dbus_daemon.cc
@@ -38,21 +38,19 @@
}
DBusServiceDaemon::DBusServiceDaemon(const std::string& service_name)
- : service_name_(service_name) {
+ : service_name_(service_name) {
}
DBusServiceDaemon::DBusServiceDaemon(
const std::string& service_name,
const dbus::ObjectPath& object_manager_path)
- : service_name_(service_name),
- object_manager_path_(object_manager_path) {
+ : service_name_(service_name), object_manager_path_(object_manager_path) {
}
-DBusServiceDaemon::DBusServiceDaemon(
- const std::string& service_name,
- base::StringPiece object_manager_path)
- : DBusServiceDaemon(service_name,
- dbus::ObjectPath(object_manager_path.as_string())) {
+DBusServiceDaemon::DBusServiceDaemon(const std::string& service_name,
+ base::StringPiece object_manager_path)
+ : DBusServiceDaemon(service_name,
+ dbus::ObjectPath(object_manager_path.as_string())) {
}
int DBusServiceDaemon::OnInit() {
@@ -62,8 +60,8 @@
scoped_refptr<AsyncEventSequencer> sequencer(new AsyncEventSequencer());
if (object_manager_path_.IsValid()) {
- object_manager_.reset(new ExportedObjectManager(bus_,
- object_manager_path_));
+ object_manager_.reset(
+ new ExportedObjectManager(bus_, object_manager_path_));
object_manager_->RegisterAsync(
sequencer->GetHandler("ObjectManager.RegisterAsync() failed.", true));
}
diff --git a/chromeos/data_encoding.cc b/chromeos/data_encoding.cc
index ba3fc1c..b3468b9 100644
--- a/chromeos/data_encoding.cc
+++ b/chromeos/data_encoding.cc
@@ -35,10 +35,9 @@
char c = *data++;
// According to RFC3986 (http://www.faqs.org/rfcs/rfc3986.html),
// section 2.3. - Unreserved Characters
- if ((c >= '0' && c <= '9') ||
- (c >= 'A' && c <= 'Z') ||
- (c >= 'a' && c <= 'z') ||
- c == '-' || c == '.' || c == '_' || c == '~') {
+ if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') ||
+ (c >= 'a' && c <= 'z') || c == '-' || c == '.' || c == '_' ||
+ c == '~') {
result += c;
} else if (c == ' ' && encodeSpaceAsPlus) {
// For historical reasons, some URLs have spaces encoded as '+',
@@ -46,7 +45,8 @@
// 'application/x-www-form-urlencoded'
result += '+';
} else {
- base::StringAppendF(&result, "%%%02X",
+ base::StringAppendF(&result,
+ "%%%02X",
static_cast<unsigned char>(c)); // Encode as %NN
}
}
@@ -60,8 +60,8 @@
int part1 = 0, part2 = 0;
// HexToDec would return -1 even for character 0 (end of string),
// so it is safe to access data[0] and data[1] without overrunning the buf.
- if (c == '%' &&
- (part1 = HexToDec(data[0])) >= 0 && (part2 = HexToDec(data[1])) >= 0) {
+ if (c == '%' && (part1 = HexToDec(data[0])) >= 0 &&
+ (part2 = HexToDec(data[1])) >= 0) {
c = static_cast<char>((part1 << 4) | part2);
data += 2;
} else if (c == '+') {
diff --git a/chromeos/data_encoding_unittest.cc b/chromeos/data_encoding_unittest.cc
index a09b09e..b7d6bdd 100644
--- a/chromeos/data_encoding_unittest.cc
+++ b/chromeos/data_encoding_unittest.cc
@@ -12,21 +12,18 @@
TEST(data_encoding, UrlEncoding) {
std::string test = "\"http://sample/path/0014.html \"";
std::string encoded = UrlEncode(test.c_str());
- EXPECT_EQ("%22http%3A%2F%2Fsample%2Fpath%2F0014.html+%22",
- encoded);
+ EXPECT_EQ("%22http%3A%2F%2Fsample%2Fpath%2F0014.html+%22", encoded);
EXPECT_EQ(test, UrlDecode(encoded.c_str()));
test = "\"http://sample/path/0014.html \"";
encoded = UrlEncode(test.c_str(), false);
- EXPECT_EQ("%22http%3A%2F%2Fsample%2Fpath%2F0014.html%20%22",
- encoded);
+ EXPECT_EQ("%22http%3A%2F%2Fsample%2Fpath%2F0014.html%20%22", encoded);
EXPECT_EQ(test, UrlDecode(encoded.c_str()));
}
TEST(data_encoding, WebParamsEncoding) {
- std::string encoded = WebParamsEncode({{"q", "test"},
- {"path", "/usr/bin"},
- {"#", "%"}});
+ std::string encoded =
+ WebParamsEncode({{"q", "test"}, {"path", "/usr/bin"}, {"#", "%"}});
EXPECT_EQ("q=test&path=%2Fusr%2Fbin&%23=%25", encoded);
auto params = WebParamsDecode(encoded);
diff --git a/chromeos/dbus/abstract_dbus_service.cc b/chromeos/dbus/abstract_dbus_service.cc
index a59922f..e0040e0 100644
--- a/chromeos/dbus/abstract_dbus_service.cc
+++ b/chromeos/dbus/abstract_dbus_service.cc
@@ -9,7 +9,7 @@
namespace chromeos {
namespace dbus {
-bool AbstractDbusService::Register(const chromeos::dbus::BusConnection &conn) {
+bool AbstractDbusService::Register(const chromeos::dbus::BusConnection& conn) {
return RegisterExclusiveService(conn,
service_interface(),
service_name(),
diff --git a/chromeos/dbus/abstract_dbus_service.h b/chromeos/dbus/abstract_dbus_service.h
index 2f4674d..c6ae5c8 100644
--- a/chromeos/dbus/abstract_dbus_service.h
+++ b/chromeos/dbus/abstract_dbus_service.h
@@ -25,7 +25,7 @@
// Registers the GObject as a service with the system DBus
// TODO(wad) make this testable by making BusConn and Proxy
// subclassing friendly.
- virtual bool Register(const chromeos::dbus::BusConnection &conn);
+ virtual bool Register(const chromeos::dbus::BusConnection& conn);
// Starts the run loop
virtual bool Run();
@@ -35,13 +35,13 @@
// Used internally during registration to set the
// proper service information.
- virtual const char *service_name() const = 0;
- virtual const char *service_path() const = 0;
- virtual const char *service_interface() const = 0;
- virtual GObject *service_object() const = 0;
+ virtual const char* service_name() const = 0;
+ virtual const char* service_path() const = 0;
+ virtual const char* service_interface() const = 0;
+ virtual GObject* service_object() const = 0;
protected:
- virtual GMainLoop *main_loop() = 0;
+ virtual GMainLoop* main_loop() = 0;
};
} // namespace dbus
diff --git a/chromeos/dbus/async_event_sequencer.cc b/chromeos/dbus/async_event_sequencer.cc
index 1991117..741bd67 100644
--- a/chromeos/dbus/async_event_sequencer.cc
+++ b/chromeos/dbus/async_event_sequencer.cc
@@ -8,24 +8,32 @@
namespace dbus_utils {
-AsyncEventSequencer::AsyncEventSequencer() { }
-AsyncEventSequencer::~AsyncEventSequencer() { }
+AsyncEventSequencer::AsyncEventSequencer() {
+}
+AsyncEventSequencer::~AsyncEventSequencer() {
+}
AsyncEventSequencer::Handler AsyncEventSequencer::GetHandler(
- const std::string& descriptive_message, bool failure_is_fatal) {
+ const std::string& descriptive_message,
+ bool failure_is_fatal) {
CHECK(!started_) << "Cannot create handlers after OnAllTasksCompletedCall()";
int unique_registration_id = ++registration_counter_;
outstanding_registrations_.insert(unique_registration_id);
- return base::Bind(&AsyncEventSequencer::HandleFinish, this,
- unique_registration_id, descriptive_message,
+ return base::Bind(&AsyncEventSequencer::HandleFinish,
+ this,
+ unique_registration_id,
+ descriptive_message,
failure_is_fatal);
}
AsyncEventSequencer::ExportHandler AsyncEventSequencer::GetExportHandler(
- const std::string& interface_name, const std::string& method_name,
- const std::string& descriptive_message, bool failure_is_fatal) {
+ const std::string& interface_name,
+ const std::string& method_name,
+ const std::string& descriptive_message,
+ bool failure_is_fatal) {
auto finish_handler = GetHandler(descriptive_message, failure_is_fatal);
- return base::Bind(&AsyncEventSequencer::HandleDBusMethodExported, this,
+ return base::Bind(&AsyncEventSequencer::HandleDBusMethodExported,
+ this,
finish_handler,
interface_name,
method_name);
@@ -42,8 +50,11 @@
namespace {
void IgnoreSuccess(const AsyncEventSequencer::CompletionTask& task,
- bool /*success*/) { task.Run(); }
-void DoNothing(bool success) {}
+ bool /*success*/) {
+ task.Run();
+}
+void DoNothing(bool success) {
+}
} // namespace
AsyncEventSequencer::CompletionAction AsyncEventSequencer::WrapCompletionTask(
@@ -52,13 +63,14 @@
}
AsyncEventSequencer::CompletionAction
- AsyncEventSequencer::GetDefaultCompletionAction() {
+AsyncEventSequencer::GetDefaultCompletionAction() {
return base::Bind(&DoNothing);
}
void AsyncEventSequencer::HandleFinish(int registration_number,
const std::string& error_message,
- bool failure_is_fatal, bool success) {
+ bool failure_is_fatal,
+ bool success) {
RetireRegistration(registration_number);
CheckForFailure(failure_is_fatal, success, error_message);
PossiblyRunCompletionActions();
@@ -69,7 +81,8 @@
const std::string& expected_interface_name,
const std::string& expected_method_name,
const std::string& actual_interface_name,
- const std::string& actual_method_name, bool success) {
+ const std::string& actual_method_name,
+ bool success) {
CHECK_EQ(expected_method_name, actual_method_name)
<< "Exported DBus method '" << actual_method_name << "' "
<< "but expected '" << expected_method_name << "'";
@@ -79,15 +92,15 @@
finish_handler.Run(success);
}
-
void AsyncEventSequencer::RetireRegistration(int registration_number) {
- const size_t handlers_retired = outstanding_registrations_.erase(
- registration_number);
- CHECK_EQ(1U, handlers_retired)
- << "Tried to retire invalid handler " << registration_number << ")";
+ const size_t handlers_retired =
+ outstanding_registrations_.erase(registration_number);
+ CHECK_EQ(1U, handlers_retired) << "Tried to retire invalid handler "
+ << registration_number << ")";
}
-void AsyncEventSequencer::CheckForFailure(bool failure_is_fatal, bool success,
+void AsyncEventSequencer::CheckForFailure(bool failure_is_fatal,
+ bool success,
const std::string& error_message) {
if (failure_is_fatal) {
CHECK(success) << error_message;
diff --git a/chromeos/dbus/async_event_sequencer.h b/chromeos/dbus/async_event_sequencer.h
index 54bcd69..f555c82 100644
--- a/chromeos/dbus/async_event_sequencer.h
+++ b/chromeos/dbus/async_event_sequencer.h
@@ -39,9 +39,9 @@
: public base::RefCounted<AsyncEventSequencer> {
public:
using Handler = base::Callback<void(bool success)>;
- using ExportHandler = base::Callback<void (const std::string& interface_name,
- const std::string& method_name,
- bool success)>;
+ using ExportHandler = base::Callback<void(const std::string& interface_name,
+ const std::string& method_name,
+ bool success)>;
using CompletionAction = base::Callback<void(bool all_succeeded)>;
using CompletionTask = base::Callback<void(void)>;
@@ -56,9 +56,10 @@
// Like GetHandler except with a signature tailored to
// ExportedObject's ExportMethod callback requirements. Will also assert
// that the passed interface/method names from ExportedObject are correct.
- ExportHandler GetExportHandler(
- const std::string& interface_name, const std::string& method_name,
- const std::string& descriptive_message, bool failure_is_fatal);
+ ExportHandler GetExportHandler(const std::string& interface_name,
+ const std::string& method_name,
+ const std::string& descriptive_message,
+ bool failure_is_fatal);
// Once all handlers obtained via GetHandler have run,
// we'll run each CompletionAction, then discard our references.
@@ -78,7 +79,8 @@
// destroy *this only when all our callbacks have been destroyed.
CHROMEOS_PRIVATE void HandleFinish(int registration_number,
const std::string& error_message,
- bool failure_is_fatal, bool success);
+ bool failure_is_fatal,
+ bool success);
// Similar to HandleFinish.
CHROMEOS_PRIVATE void HandleDBusMethodExported(
const Handler& finish_handler,
diff --git a/chromeos/dbus/async_event_sequencer_unittest.cc b/chromeos/dbus/async_event_sequencer_unittest.cc
index 49dcfb4..91e39cc 100644
--- a/chromeos/dbus/async_event_sequencer_unittest.cc
+++ b/chromeos/dbus/async_event_sequencer_unittest.cc
@@ -25,9 +25,9 @@
MOCK_METHOD1(HandleCompletion, void(bool all_succeeded));
void SetUp() {
- aec_ = new AsyncEventSequencer();
- cb_ = base::Bind(&AsyncEventSequencerTest::HandleCompletion,
- base::Unretained(this));
+ aec_ = new AsyncEventSequencer();
+ cb_ = base::Bind(&AsyncEventSequencerTest::HandleCompletion,
+ base::Unretained(this));
}
scoped_refptr<AsyncEventSequencer> aec_;
@@ -60,9 +60,9 @@
}
TEST_F(AsyncEventSequencerTest, MultiDBusActionsSucceed) {
- auto handler1 = aec_->GetExportHandler(
+ auto handler1 = aec_->GetExportHandler(
kTestInterface, kTestMethod1, "method export failed", false);
- auto handler2 = aec_->GetExportHandler(
+ auto handler2 = aec_->GetExportHandler(
kTestInterface, kTestMethod2, "method export failed", false);
aec_->OnAllTasksCompletedCall({cb_});
handler1.Run(kTestInterface, kTestMethod1, true);
@@ -71,9 +71,9 @@
}
TEST_F(AsyncEventSequencerTest, SomeDBusActionsFail) {
- auto handler1 = aec_->GetExportHandler(
+ auto handler1 = aec_->GetExportHandler(
kTestInterface, kTestMethod1, "method export failed", false);
- auto handler2 = aec_->GetExportHandler(
+ auto handler2 = aec_->GetExportHandler(
kTestInterface, kTestMethod2, "method export failed", false);
aec_->OnAllTasksCompletedCall({cb_});
handler1.Run(kTestInterface, kTestMethod1, true);
@@ -82,7 +82,7 @@
}
TEST_F(AsyncEventSequencerTest, MixedActions) {
- auto handler1 = aec_->GetExportHandler(
+ auto handler1 = aec_->GetExportHandler(
kTestInterface, kTestMethod1, "method export failed", false);
auto handler2 = aec_->GetHandler("handler failed", false);
aec_->OnAllTasksCompletedCall({cb_});
diff --git a/chromeos/dbus/data_serialization.cc b/chromeos/dbus/data_serialization.cc
index b389ce0..b2141aa 100644
--- a/chromeos/dbus/data_serialization.cc
+++ b/chromeos/dbus/data_serialization.cc
@@ -172,8 +172,7 @@
// std::map<KEY, VALUE> overload.
template<typename KEY, typename VALUE>
-bool PopTypedMapFromReader(dbus::MessageReader* reader,
- chromeos::Any* value) {
+bool PopTypedMapFromReader(dbus::MessageReader* reader, chromeos::Any* value) {
return PopTypedValueFromReader<std::map<KEY, VALUE>>(reader, value);
}
@@ -221,7 +220,7 @@
// When a use case for particular array signature is found, feel free
// to add handing for it here.
LOG(ERROR) << "Variant de-serialization of array containing data of "
- << "type '" << signature << "' is not yet supported";
+ << "type '" << signature << "' is not yet supported";
return false;
}
@@ -239,8 +238,8 @@
// When a use case for particular struct signature is found, feel free
// to add handing for it here.
- LOG(ERROR) << "Variant de-serialization of structs of type '"
- << signature << "' is not yet supported";
+ LOG(ERROR) << "Variant de-serialization of structs of type '" << signature
+ << "' is not yet supported";
return false;
}
diff --git a/chromeos/dbus/data_serialization.h b/chromeos/dbus/data_serialization.h
index 05691f7..dc6b875 100644
--- a/chromeos/dbus/data_serialization.h
+++ b/chromeos/dbus/data_serialization.h
@@ -95,14 +95,17 @@
// supported.
template<typename T, typename... Types>
struct IsTypeSupported<T, Types...>
- : public std::integral_constant<bool, IsTypeSupported<T>::value &&
- IsTypeSupported<Types...>::value> {};
+ : public std::integral_constant<
+ bool,
+ IsTypeSupported<T>::value && IsTypeSupported<Types...>::value> {};
// For a single type T, check if DBusType<T> derives from Unsupported.
// If it does, then the type is not supported by the D-Bus.
template<typename T>
-struct IsTypeSupported<T> : public std::integral_constant<
- bool, !std::is_base_of<Unsupported, DBusType<T>>::value> {};
+struct IsTypeSupported<T>
+ : public std::integral_constant<
+ bool,
+ !std::is_base_of<Unsupported, DBusType<T>>::value> {};
// Empty set is not supported.
template<>
@@ -154,9 +157,8 @@
// into the Variant and updates the |*reader_ref| with the transient
// |variant_reader| MessageReader instance passed in.
// Returns false if it fails to descend into the Variant.
-inline bool DescendIntoVariantIfPresent(
- dbus::MessageReader** reader_ref,
- dbus::MessageReader* variant_reader) {
+inline bool DescendIntoVariantIfPresent(dbus::MessageReader** reader_ref,
+ dbus::MessageReader* variant_reader) {
if ((*reader_ref)->GetDataType() != dbus::Message::VARIANT)
return true;
if (!(*reader_ref)->PopVariant(variant_reader))
@@ -189,10 +191,10 @@
// DBusType<T> for various C++ types that can be serialized over D-Bus.
// bool -----------------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
- dbus::MessageWriter* writer, bool value);
-CHROMEOS_EXPORT bool PopValueFromReader(
- dbus::MessageReader* reader, bool* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+ bool value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+ bool* value);
template<>
struct DBusType<bool> {
@@ -208,16 +210,14 @@
};
// uint8_t --------------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
- dbus::MessageWriter* writer, uint8_t value);
-CHROMEOS_EXPORT bool PopValueFromReader(
- dbus::MessageReader* reader, uint8_t* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+ uint8_t value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+ uint8_t* value);
template<>
struct DBusType<uint8_t> {
- inline static std::string GetSignature() {
- return DBUS_TYPE_BYTE_AS_STRING;
- }
+ inline static std::string GetSignature() { return DBUS_TYPE_BYTE_AS_STRING; }
inline static void Write(dbus::MessageWriter* writer, uint8_t value) {
AppendValueToWriter(writer, value);
}
@@ -227,16 +227,14 @@
};
// int16_t --------------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
- dbus::MessageWriter* writer, int16_t value);
-CHROMEOS_EXPORT bool PopValueFromReader(
- dbus::MessageReader* reader, int16_t* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+ int16_t value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+ int16_t* value);
template<>
struct DBusType<int16_t> {
- inline static std::string GetSignature() {
- return DBUS_TYPE_INT16_AS_STRING;
- }
+ inline static std::string GetSignature() { return DBUS_TYPE_INT16_AS_STRING; }
inline static void Write(dbus::MessageWriter* writer, int16_t value) {
AppendValueToWriter(writer, value);
}
@@ -246,10 +244,10 @@
};
// uint16_t -------------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
- dbus::MessageWriter* writer, uint16_t value);
-CHROMEOS_EXPORT bool PopValueFromReader(
- dbus::MessageReader* reader, uint16_t* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+ uint16_t value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+ uint16_t* value);
template<>
struct DBusType<uint16_t> {
@@ -265,16 +263,14 @@
};
// int32_t --------------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
- dbus::MessageWriter* writer, int32_t value);
-CHROMEOS_EXPORT bool PopValueFromReader(
- dbus::MessageReader* reader, int32_t* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+ int32_t value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+ int32_t* value);
template<>
struct DBusType<int32_t> {
- inline static std::string GetSignature() {
- return DBUS_TYPE_INT32_AS_STRING;
- }
+ inline static std::string GetSignature() { return DBUS_TYPE_INT32_AS_STRING; }
inline static void Write(dbus::MessageWriter* writer, int32_t value) {
AppendValueToWriter(writer, value);
}
@@ -284,10 +280,10 @@
};
// uint32_t -------------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
- dbus::MessageWriter* writer, uint32_t value);
-CHROMEOS_EXPORT bool PopValueFromReader(
- dbus::MessageReader* reader, uint32_t* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+ uint32_t value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+ uint32_t* value);
template<>
struct DBusType<uint32_t> {
@@ -303,16 +299,14 @@
};
// int64_t --------------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
- dbus::MessageWriter* writer, int64_t value);
-CHROMEOS_EXPORT bool PopValueFromReader(
- dbus::MessageReader* reader, int64_t* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+ int64_t value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+ int64_t* value);
template<>
struct DBusType<int64_t> {
- inline static std::string GetSignature() {
- return DBUS_TYPE_INT64_AS_STRING;
- }
+ inline static std::string GetSignature() { return DBUS_TYPE_INT64_AS_STRING; }
inline static void Write(dbus::MessageWriter* writer, int64_t value) {
AppendValueToWriter(writer, value);
}
@@ -322,10 +316,10 @@
};
// uint64_t -------------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
- dbus::MessageWriter* writer, uint64_t value);
-CHROMEOS_EXPORT bool PopValueFromReader(
- dbus::MessageReader* reader, uint64_t* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+ uint64_t value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+ uint64_t* value);
template<>
struct DBusType<uint64_t> {
@@ -341,10 +335,10 @@
};
// double ---------------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
- dbus::MessageWriter* writer, double value);
-CHROMEOS_EXPORT bool PopValueFromReader(
- dbus::MessageReader* reader, double* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+ double value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+ double* value);
template<>
struct DBusType<double> {
@@ -360,10 +354,10 @@
};
// std::string ----------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
- dbus::MessageWriter* writer, const std::string& value);
-CHROMEOS_EXPORT bool PopValueFromReader(
- dbus::MessageReader* reader, std::string* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+ const std::string& value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+ std::string* value);
template<>
struct DBusType<std::string> {
@@ -380,8 +374,8 @@
};
// const char*
-CHROMEOS_EXPORT void AppendValueToWriter(
- dbus::MessageWriter* writer, const char* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+ const char* value);
template<>
struct DBusType<const char*> {
@@ -405,10 +399,10 @@
};
// dbus::ObjectPath -----------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
- dbus::MessageWriter* writer, const dbus::ObjectPath& value);
-CHROMEOS_EXPORT bool PopValueFromReader(
- dbus::MessageReader* reader, dbus::ObjectPath* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+ const dbus::ObjectPath& value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+ dbus::ObjectPath* value);
template<>
struct DBusType<dbus::ObjectPath> {
@@ -426,10 +420,10 @@
};
// dbus::FileDescriptor -------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
- dbus::MessageWriter* writer, const dbus::FileDescriptor& value);
-CHROMEOS_EXPORT bool PopValueFromReader(
- dbus::MessageReader* reader, dbus::FileDescriptor* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+ const dbus::FileDescriptor& value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+ dbus::FileDescriptor* value);
template<>
struct DBusType<dbus::FileDescriptor> {
@@ -449,8 +443,8 @@
// chromeos::Any --------------------------------------------------------------
CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
const chromeos::Any& value);
-CHROMEOS_EXPORT bool PopValueFromReader(
- dbus::MessageReader* reader, chromeos::Any* value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+ chromeos::Any* value);
template<>
struct DBusType<chromeos::Any> {
@@ -468,9 +462,9 @@
// std::vector = D-Bus ARRAY. -------------------------------------------------
template<typename T, typename ALLOC>
-typename std::enable_if<IsTypeSupported<T>::value>::type
-AppendValueToWriter(dbus::MessageWriter* writer,
- const std::vector<T, ALLOC>& value) {
+typename std::enable_if<IsTypeSupported<T>::value>::type AppendValueToWriter(
+ dbus::MessageWriter* writer,
+ const std::vector<T, ALLOC>& value) {
dbus::MessageWriter array_writer(nullptr);
writer->OpenArray(GetDBusSignature<T>(), &array_writer);
for (const auto& element : value) {
@@ -552,9 +546,7 @@
template<>
struct TupleTraits<> {
- static std::string GetSignature() {
- return std::string{};
- }
+ static std::string GetSignature() { return std::string{}; }
};
} // namespace details
@@ -562,14 +554,15 @@
template<typename... Types>
inline std::string GetStructDBusSignature() {
// Returns "(T...)", where "T..." is the signature strings for types T...
- return DBUS_STRUCT_BEGIN_CHAR_AS_STRING +
- details::TupleTraits<Types...>::GetSignature() +
- DBUS_STRUCT_END_CHAR_AS_STRING;
+ return DBUS_STRUCT_BEGIN_CHAR_AS_STRING +
+ details::TupleTraits<Types...>::GetSignature() +
+ DBUS_STRUCT_END_CHAR_AS_STRING;
}
template<typename U, typename V>
-typename std::enable_if<IsTypeSupported<U, V>::value>::type
-AppendValueToWriter(dbus::MessageWriter* writer, const std::pair<U, V>& value) {
+typename std::enable_if<IsTypeSupported<U, V>::value>::type AppendValueToWriter(
+ dbus::MessageWriter* writer,
+ const std::pair<U, V>& value) {
dbus::MessageWriter struct_writer(nullptr);
writer->OpenStruct(&struct_writer);
// Use DBusType<T>::Write() instead of AppendValueToWriter() to delay
@@ -623,8 +616,7 @@
template<typename U, typename V>
struct DBusType<std::pair<U, V>>
- : public details::DBusPairType<IsTypeSupported<U, V>::value, U, V> {
-};
+ : public details::DBusPairType<IsTypeSupported<U, V>::value, U, V> {};
// std::tuple = D-Bus STRUCT with arbitrary number of members. ----------------
namespace details {
@@ -664,17 +656,15 @@
struct TupleIterator<N, N, T...> {
using Tuple = std::tuple<T...>;
static void Write(dbus::MessageWriter* writer, const Tuple& value) {}
- static bool Read(dbus::MessageReader* reader, Tuple* value) {
- return true;
- }
+ static bool Read(dbus::MessageReader* reader, Tuple* value) { return true; }
};
} // namespace details
template<typename... T>
-typename std::enable_if<IsTypeSupported<T...>::value>::type
-AppendValueToWriter(dbus::MessageWriter* writer,
- const std::tuple<T...>& value) {
+typename std::enable_if<IsTypeSupported<T...>::value>::type AppendValueToWriter(
+ dbus::MessageWriter* writer,
+ const std::tuple<T...>& value) {
dbus::MessageWriter struct_writer(nullptr);
writer->OpenStruct(&struct_writer);
details::TupleIterator<0, sizeof...(T), T...>::Write(&struct_writer, value);
@@ -727,9 +717,8 @@
// std::map = D-Bus ARRAY of DICT_ENTRY. --------------------------------------
template<typename KEY, typename VALUE, typename PRED, typename ALLOC>
typename std::enable_if<IsTypeSupported<KEY, VALUE>::value>::type
-AppendValueToWriter(
- dbus::MessageWriter* writer,
- const std::map<KEY, VALUE, PRED, ALLOC>& value) {
+AppendValueToWriter(dbus::MessageWriter* writer,
+ const std::map<KEY, VALUE, PRED, ALLOC>& value) {
dbus::MessageWriter dict_writer(nullptr);
writer->OpenArray(details::GetDBusDictEntryType<KEY, VALUE>(), &dict_writer);
for (const auto& pair : value) {
@@ -778,7 +767,10 @@
// GetSignature/Write/Read methods for T types that are supported by D-Bus
// and not having those methods for types that are not supported by D-Bus.
template<bool inner_types_supported,
- typename KEY, typename VALUE, typename PRED, typename ALLOC>
+ typename KEY,
+ typename VALUE,
+ typename PRED,
+ typename ALLOC>
struct DBusMapType {
// Returns "a{KV}", where "K" and "V" are the signature strings for types
// KEY/VALUE.
@@ -804,7 +796,10 @@
template<typename KEY, typename VALUE, typename PRED, typename ALLOC>
struct DBusType<std::map<KEY, VALUE, PRED, ALLOC>>
: public details::DBusMapType<IsTypeSupported<KEY, VALUE>::value,
- KEY, VALUE, PRED, ALLOC> {};
+ KEY,
+ VALUE,
+ PRED,
+ ALLOC> {};
// google::protobuf::MessageLite = D-Bus ARRAY of BYTE ------------------------
inline void AppendValueToWriter(dbus::MessageWriter* writer,
diff --git a/chromeos/dbus/data_serialization_unittest.cc b/chromeos/dbus/data_serialization_unittest.cc
index 8326184..547d8a1 100644
--- a/chromeos/dbus/data_serialization_unittest.cc
+++ b/chromeos/dbus/data_serialization_unittest.cc
@@ -44,8 +44,8 @@
EXPECT_TRUE(IsTypeSupported<std::vector<bool>>::value);
EXPECT_TRUE(IsTypeSupported<std::vector<uint8_t>>::value);
EXPECT_TRUE((IsTypeSupported<std::pair<int16_t, double>>::value));
- EXPECT_TRUE((IsTypeSupported<std::map<uint16_t,
- std::vector<int64_t>>>::value));
+ EXPECT_TRUE(
+ (IsTypeSupported<std::map<uint16_t, std::vector<int64_t>>>::value));
EXPECT_TRUE((IsTypeSupported<std::tuple<bool, double, int32_t>>::value));
}
@@ -111,7 +111,8 @@
EXPECT_EQ("a{ss}", (GetDBusSignature<std::map<std::string, std::string>>()));
EXPECT_EQ("a{sv}", (GetDBusSignature<std::map<std::string, Any>>()));
EXPECT_EQ("a{id}", (GetDBusSignature<std::map<int, double>>()));
- EXPECT_EQ("a{ia{ss}}",
+ EXPECT_EQ(
+ "a{ia{ss}}",
(GetDBusSignature<std::map<int, std::map<std::string, std::string>>>()));
}
@@ -125,8 +126,8 @@
EXPECT_EQ("(i)", (GetDBusSignature<std::tuple<int>>()));
EXPECT_EQ("(sv)", (GetDBusSignature<std::tuple<std::string, Any>>()));
EXPECT_EQ("(id(si))",
- (GetDBusSignature<std::tuple<int, double,
- std::tuple<std::string, int>>>()));
+ (GetDBusSignature<
+ std::tuple<int, double, std::tuple<std::string, int>>>()));
}
// Test that a byte can be properly written and read. We only have this
@@ -147,7 +148,7 @@
uint8_t byte_value = 0;
EXPECT_TRUE(PopValueFromReader(&reader, &byte_value));
- EXPECT_EQ(123, byte_value); // Should match with the input.
+ EXPECT_EQ(123, byte_value); // Should match with the input.
EXPECT_FALSE(reader.HasMoreData()); // Should not have more data to read.
// Try to get another byte. Should fail.
@@ -437,9 +438,9 @@
std::unique_ptr<Response> message(Response::CreateEmpty().release());
MessageWriter writer(message.get());
std::vector<ObjectPath> object_paths{
- ObjectPath("/object/path/1"),
- ObjectPath("/object/path/2"),
- ObjectPath("/object/path/3"),
+ ObjectPath("/object/path/1"),
+ ObjectPath("/object/path/2"),
+ ObjectPath("/object/path/3"),
};
AppendValueToWriter(&writer, object_paths);
@@ -517,24 +518,15 @@
EXPECT_TRUE(PopValueFromReader(&reader, &values_out));
EXPECT_FALSE(reader.HasMoreData());
EXPECT_EQ(values.size(), values_out.size());
- EXPECT_EQ(values["key1"].Get<uint8_t>(),
- values_out["key1"].Get<uint8_t>());
- EXPECT_EQ(values["key2"].Get<bool>(),
- values_out["key2"].Get<bool>());
- EXPECT_EQ(values["key3"].Get<int16_t>(),
- values_out["key3"].Get<int16_t>());
- EXPECT_EQ(values["key4"].Get<uint16_t>(),
- values_out["key4"].Get<uint16_t>());
- EXPECT_EQ(values["key5"].Get<int32_t>(),
- values_out["key5"].Get<int32_t>());
- EXPECT_EQ(values["key6"].Get<uint32_t>(),
- values_out["key6"].Get<uint32_t>());
- EXPECT_EQ(values["key7"].Get<int64_t>(),
- values_out["key7"].Get<int64_t>());
- EXPECT_EQ(values["key8"].Get<uint64_t>(),
- values_out["key8"].Get<uint64_t>());
- EXPECT_EQ(values["key9"].Get<double>(),
- values_out["key9"].Get<double>());
+ EXPECT_EQ(values["key1"].Get<uint8_t>(), values_out["key1"].Get<uint8_t>());
+ EXPECT_EQ(values["key2"].Get<bool>(), values_out["key2"].Get<bool>());
+ EXPECT_EQ(values["key3"].Get<int16_t>(), values_out["key3"].Get<int16_t>());
+ EXPECT_EQ(values["key4"].Get<uint16_t>(), values_out["key4"].Get<uint16_t>());
+ EXPECT_EQ(values["key5"].Get<int32_t>(), values_out["key5"].Get<int32_t>());
+ EXPECT_EQ(values["key6"].Get<uint32_t>(), values_out["key6"].Get<uint32_t>());
+ EXPECT_EQ(values["key7"].Get<int64_t>(), values_out["key7"].Get<int64_t>());
+ EXPECT_EQ(values["key8"].Get<uint64_t>(), values_out["key8"].Get<uint64_t>());
+ EXPECT_EQ(values["key9"].Get<double>(), values_out["key9"].Get<double>());
EXPECT_EQ(values["keyA"].Get<std::string>(),
values_out["keyA"].Get<std::string>());
EXPECT_EQ(values["keyB"].Get<ObjectPath>(),
@@ -649,8 +641,7 @@
int age;
// Provide == operator so we can easily compare arrays of Person.
bool operator==(const Person& rhs) const {
- return first_name == rhs.first_name &&
- last_name == rhs.last_name &&
+ return first_name == rhs.first_name && last_name == rhs.last_name &&
age == rhs.age;
}
};
@@ -730,7 +721,7 @@
EXPECT_EQ("aa{i(ssi)}", message->GetSignature());
- std::vector<std::map<int, Person>> data_out;;
+ std::vector<std::map<int, Person>> data_out;
MessageReader reader(message.get());
EXPECT_TRUE(PopValueFromReader(&reader, &data_out));
diff --git a/chromeos/dbus/dbus.h b/chromeos/dbus/dbus.h
index 177a6b8..abde7dd 100644
--- a/chromeos/dbus/dbus.h
+++ b/chromeos/dbus/dbus.h
@@ -37,8 +37,7 @@
public:
typedef ::DBusGConnection* value_type;
- BusConnection(const BusConnection& x)
- : object_(x.object_) {
+ BusConnection(const BusConnection& x) : object_(x.object_) {
if (object_)
::dbus_g_connection_ref(object_);
}
@@ -58,13 +57,9 @@
return object_;
}
- operator bool() const {
- return object_;
- }
+ operator bool() const { return object_; }
- bool HasConnection() const {
- return object_;
- }
+ bool HasConnection() const { return object_; }
private:
friend void swap(BusConnection& x, BusConnection& y);
@@ -74,9 +69,7 @@
friend BusConnection GetPrivateBusConnection(const char* address);
// Constructor takes ownership
- CHROMEOS_PRIVATE explicit BusConnection(::DBusGConnection* x)
- : object_(x) {
- }
+ CHROMEOS_PRIVATE explicit BusConnection(::DBusGConnection* x) : object_(x) {}
value_type object_;
};
@@ -139,17 +132,14 @@
return object_;
}
- operator bool() const {
- return object_;
- }
+ operator bool() const { return object_; }
private:
- CHROMEOS_PRIVATE static value_type GetGProxy(
- const BusConnection& connection,
- const char* name,
- const char* path,
- const char* interface,
- bool connect_to_name_owner);
+ CHROMEOS_PRIVATE static value_type GetGProxy(const BusConnection& connection,
+ const char* name,
+ const char* path,
+ const char* interface,
+ bool connect_to_name_owner);
CHROMEOS_PRIVATE static value_type GetGPeerProxy(
const BusConnection& connection,
@@ -183,26 +173,23 @@
const char* service_path,
GObject* object);
-template <typename F> // F is a function signature
+template<typename F> // F is a function signature
class MonitorConnection;
-template <typename A1>
+template<typename A1>
class MonitorConnection<void(A1)> {
public:
- MonitorConnection(const Proxy& proxy, const char* name,
- void (*monitor)(void*, A1), void* object)
- : proxy_(proxy), name_(name), monitor_(monitor), object_(object) {
- }
+ MonitorConnection(const Proxy& proxy,
+ const char* name,
+ void (*monitor)(void*, A1),
+ void* object)
+ : proxy_(proxy), name_(name), monitor_(monitor), object_(object) {}
static void Run(::DBusGProxy*, A1 x, MonitorConnection* self) {
self->monitor_(self->object_, x);
}
- const Proxy& proxy() const {
- return proxy_;
- }
- const std::string& name() const {
- return name_;
- }
+ const Proxy& proxy() const { return proxy_; }
+ const std::string& name() const { return name_; }
private:
Proxy proxy_;
@@ -211,23 +198,20 @@
void* object_;
};
-template <typename A1, typename A2>
+template<typename A1, typename A2>
class MonitorConnection<void(A1, A2)> {
public:
- MonitorConnection(const Proxy& proxy, const char* name,
- void (*monitor)(void*, A1, A2), void* object)
- : proxy_(proxy), name_(name), monitor_(monitor), object_(object) {
- }
+ MonitorConnection(const Proxy& proxy,
+ const char* name,
+ void (*monitor)(void*, A1, A2),
+ void* object)
+ : proxy_(proxy), name_(name), monitor_(monitor), object_(object) {}
static void Run(::DBusGProxy*, A1 x, A2 y, MonitorConnection* self) {
self->monitor_(self->object_, x, y);
}
- const Proxy& proxy() const {
- return proxy_;
- }
- const std::string& name() const {
- return name_;
- }
+ const Proxy& proxy() const { return proxy_; }
+ const std::string& name() const { return name_; }
private:
Proxy proxy_;
@@ -236,23 +220,20 @@
void* object_;
};
-template <typename A1, typename A2, typename A3>
+template<typename A1, typename A2, typename A3>
class MonitorConnection<void(A1, A2, A3)> {
public:
- MonitorConnection(const Proxy& proxy, const char* name,
- void (*monitor)(void*, A1, A2, A3), void* object)
- : proxy_(proxy), name_(name), monitor_(monitor), object_(object) {
- }
+ MonitorConnection(const Proxy& proxy,
+ const char* name,
+ void (*monitor)(void*, A1, A2, A3),
+ void* object)
+ : proxy_(proxy), name_(name), monitor_(monitor), object_(object) {}
static void Run(::DBusGProxy*, A1 x, A2 y, A3 z, MonitorConnection* self) {
self->monitor_(self->object_, x, y, z);
}
- const Proxy& proxy() const {
- return proxy_;
- }
- const std::string& name() const {
- return name_;
- }
+ const Proxy& proxy() const { return proxy_; }
+ const std::string& name() const { return name_; }
private:
Proxy proxy_;
@@ -261,24 +242,25 @@
void* object_;
};
-template <typename A1, typename A2, typename A3, typename A4>
+template<typename A1, typename A2, typename A3, typename A4>
class MonitorConnection<void(A1, A2, A3, A4)> {
public:
- MonitorConnection(const Proxy& proxy, const char* name,
- void (*monitor)(void*, A1, A2, A3, A4), void* object)
- : proxy_(proxy), name_(name), monitor_(monitor), object_(object) {
- }
+ MonitorConnection(const Proxy& proxy,
+ const char* name,
+ void (*monitor)(void*, A1, A2, A3, A4),
+ void* object)
+ : proxy_(proxy), name_(name), monitor_(monitor), object_(object) {}
- static void Run(::DBusGProxy*, A1 x, A2 y, A3 z, A4 w,
+ static void Run(::DBusGProxy*,
+ A1 x,
+ A2 y,
+ A3 z,
+ A4 w,
MonitorConnection* self) {
self->monitor_(self->object_, x, y, z, w);
}
- const Proxy& proxy() const {
- return proxy_;
- }
- const std::string& name() const {
- return name_;
- }
+ const Proxy& proxy() const { return proxy_; }
+ const std::string& name() const { return name_; }
private:
Proxy proxy_;
@@ -287,82 +269,84 @@
void* object_;
};
-template <typename A1>
-MonitorConnection<void(A1)>* Monitor(const Proxy& proxy, const char* name,
+template<typename A1>
+MonitorConnection<void(A1)>* Monitor(const Proxy& proxy,
+ const char* name,
void (*monitor)(void*, A1),
void* object) {
- typedef MonitorConnection<void (A1)> ConnectionType;
+ typedef MonitorConnection<void(A1)> ConnectionType;
ConnectionType* result = new ConnectionType(proxy, name, monitor, object);
- ::dbus_g_proxy_add_signal(proxy.gproxy(), name,
- glib::type_to_gtypeid<A1>(), G_TYPE_INVALID);
- ::dbus_g_proxy_connect_signal(proxy.gproxy(), name,
- G_CALLBACK(&ConnectionType::Run),
- result, nullptr);
+ ::dbus_g_proxy_add_signal(
+ proxy.gproxy(), name, glib::type_to_gtypeid<A1>(), G_TYPE_INVALID);
+ ::dbus_g_proxy_connect_signal(
+ proxy.gproxy(), name, G_CALLBACK(&ConnectionType::Run), result, nullptr);
return result;
}
-template <typename A1, typename A2>
-MonitorConnection<void(A1, A2)>* Monitor(const Proxy& proxy, const char* name,
+template<typename A1, typename A2>
+MonitorConnection<void(A1, A2)>* Monitor(const Proxy& proxy,
+ const char* name,
void (*monitor)(void*, A1, A2),
void* object) {
- typedef MonitorConnection<void (A1, A2)> ConnectionType;
+ typedef MonitorConnection<void(A1, A2)> ConnectionType;
ConnectionType* result = new ConnectionType(proxy, name, monitor, object);
- ::dbus_g_proxy_add_signal(proxy.gproxy(), name,
+ ::dbus_g_proxy_add_signal(proxy.gproxy(),
+ name,
glib::type_to_gtypeid<A1>(),
glib::type_to_gtypeid<A2>(),
G_TYPE_INVALID);
- ::dbus_g_proxy_connect_signal(proxy.gproxy(), name,
- G_CALLBACK(&ConnectionType::Run),
- result, nullptr);
+ ::dbus_g_proxy_connect_signal(
+ proxy.gproxy(), name, G_CALLBACK(&ConnectionType::Run), result, nullptr);
return result;
}
-template <typename A1, typename A2, typename A3>
+template<typename A1, typename A2, typename A3>
MonitorConnection<void(A1, A2, A3)>* Monitor(const Proxy& proxy,
- const char* name,
- void (*monitor)(void*, A1, A2, A3),
- void* object) {
- typedef MonitorConnection<void (A1, A2, A3)> ConnectionType;
+ const char* name,
+ void (*monitor)(void*, A1, A2, A3),
+ void* object) {
+ typedef MonitorConnection<void(A1, A2, A3)> ConnectionType;
ConnectionType* result = new ConnectionType(proxy, name, monitor, object);
- ::dbus_g_proxy_add_signal(proxy.gproxy(), name,
+ ::dbus_g_proxy_add_signal(proxy.gproxy(),
+ name,
glib::type_to_gtypeid<A1>(),
glib::type_to_gtypeid<A2>(),
glib::type_to_gtypeid<A3>(),
G_TYPE_INVALID);
- ::dbus_g_proxy_connect_signal(proxy.gproxy(), name,
- G_CALLBACK(&ConnectionType::Run),
- result, nullptr);
+ ::dbus_g_proxy_connect_signal(
+ proxy.gproxy(), name, G_CALLBACK(&ConnectionType::Run), result, nullptr);
return result;
}
-template <typename A1, typename A2, typename A3, typename A4>
-MonitorConnection<void(A1, A2, A3, A4)>* Monitor(const Proxy& proxy,
+template<typename A1, typename A2, typename A3, typename A4>
+MonitorConnection<void(A1, A2, A3, A4)>* Monitor(
+ const Proxy& proxy,
const char* name,
void (*monitor)(void*, A1, A2, A3, A4),
void* object) {
- typedef MonitorConnection<void (A1, A2, A3, A4)> ConnectionType;
+ typedef MonitorConnection<void(A1, A2, A3, A4)> ConnectionType;
ConnectionType* result = new ConnectionType(proxy, name, monitor, object);
- ::dbus_g_proxy_add_signal(proxy.gproxy(), name,
+ ::dbus_g_proxy_add_signal(proxy.gproxy(),
+ name,
glib::type_to_gtypeid<A1>(),
glib::type_to_gtypeid<A2>(),
glib::type_to_gtypeid<A3>(),
glib::type_to_gtypeid<A4>(),
G_TYPE_INVALID);
- ::dbus_g_proxy_connect_signal(proxy.gproxy(), name,
- G_CALLBACK(&ConnectionType::Run),
- result, nullptr);
+ ::dbus_g_proxy_connect_signal(
+ proxy.gproxy(), name, G_CALLBACK(&ConnectionType::Run), result, nullptr);
return result;
}
-template <typename F>
+template<typename F>
void Disconnect(MonitorConnection<F>* connection) {
typedef MonitorConnection<F> ConnectionType;
@@ -407,7 +391,7 @@
// std::cout << "Battery charge is " << x << "% of capacity.";
// \end_example
-template <typename T>
+template<typename T>
inline bool RetrieveProperty(const Proxy& proxy,
const char* interface,
const char* property,
diff --git a/chromeos/dbus/dbus_method_invoker.h b/chromeos/dbus/dbus_method_invoker.h
index c3d45ab..450f353 100644
--- a/chromeos/dbus/dbus_method_invoker.h
+++ b/chromeos/dbus/dbus_method_invoker.h
@@ -106,10 +106,15 @@
&method_call, timeout_ms, &dbus_error);
if (!response) {
if (dbus_error.is_set()) {
- Error::AddTo(error, FROM_HERE, errors::dbus::kDomain,
- dbus_error.name(), dbus_error.message());
+ Error::AddTo(error,
+ FROM_HERE,
+ errors::dbus::kDomain,
+ dbus_error.name(),
+ dbus_error.message());
} else {
- Error::AddToPrintf(error, FROM_HERE, errors::dbus::kDomain,
+ Error::AddToPrintf(error,
+ FROM_HERE,
+ errors::dbus::kDomain,
DBUS_ERROR_FAILED,
"Failed to call D-Bus method: %s.%s",
interface_name.c_str(),
@@ -146,8 +151,8 @@
auto callback = [val_tuple](const ResultTypes&... params) {
*val_tuple = std::tie(params...);
};
- return DBusParamReader<false, ResultTypes...>::Invoke(callback, reader,
- error);
+ return DBusParamReader<false, ResultTypes...>::Invoke(
+ callback, reader, error);
}
// Overload of ExtractMessageParametersAsTuple to handle reference types in
// tuples created with std::tie().
@@ -159,8 +164,8 @@
auto callback = [ref_tuple](const ResultTypes&... params) {
*ref_tuple = std::tie(params...);
};
- return DBusParamReader<false, ResultTypes...>::Invoke(callback, reader,
- error);
+ return DBusParamReader<false, ResultTypes...>::Invoke(
+ callback, reader, error);
}
// A helper method to extract a list of values from a message buffer.
@@ -181,8 +186,8 @@
ErrorPtr* error,
ResultTypes*... results) {
auto ref_tuple = std::tie(*results...);
- return ExtractMessageParametersAsTuple<ResultTypes...>(reader, error,
- &ref_tuple);
+ return ExtractMessageParametersAsTuple<ResultTypes...>(
+ reader, error, &ref_tuple);
}
// Convenient helper method to extract return value(s) of a D-Bus method call.
@@ -267,9 +272,8 @@
dbus::ObjectProxy::ErrorCallback dbus_error_callback =
base::Bind(&TranslateErrorResponse, error_callback);
- dbus::ObjectProxy::ResponseCallback dbus_success_callback =
- base::Bind(&TranslateSuccessResponse<OutArgs...>,
- success_callback, error_callback);
+ dbus::ObjectProxy::ResponseCallback dbus_success_callback = base::Bind(
+ &TranslateSuccessResponse<OutArgs...>, success_callback, error_callback);
object->CallMethodWithErrorCallback(
&method_call, timeout_ms, dbus_success_callback, dbus_error_callback);
@@ -277,13 +281,12 @@
// Same as CallMethodWithTimeout() but uses a default timeout value.
template<typename... InArgs, typename... OutArgs>
-inline void CallMethod(
- dbus::ObjectProxy* object,
- const std::string& interface_name,
- const std::string& method_name,
- const base::Callback<void(OutArgs...)>& success_callback,
- const AsyncErrorCallback& error_callback,
- const InArgs&... params) {
+inline void CallMethod(dbus::ObjectProxy* object,
+ const std::string& interface_name,
+ const std::string& method_name,
+ const base::Callback<void(OutArgs...)>& success_callback,
+ const AsyncErrorCallback& error_callback,
+ const InArgs&... params) {
return CallMethodWithTimeout(dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
object,
interface_name,
diff --git a/chromeos/dbus/dbus_method_invoker_unittest.cc b/chromeos/dbus/dbus_method_invoker_unittest.cc
index 7b7d373..70539bf 100644
--- a/chromeos/dbus/dbus_method_invoker_unittest.cc
+++ b/chromeos/dbus/dbus_method_invoker_unittest.cc
@@ -32,7 +32,7 @@
const char kTestMethod1[] = "TestMethod1";
const char kTestMethod2[] = "TestMethod2";
-class DBusMethodInvokerTest: public testing::Test {
+class DBusMethodInvokerTest : public testing::Test {
public:
void SetUp() override {
dbus::Bus::Options options;
@@ -44,8 +44,8 @@
// Use a mock exported object.
mock_object_proxy_ = new dbus::MockObjectProxy(
bus_.get(), kTestServiceName, dbus::ObjectPath(kTestPath));
- EXPECT_CALL(*bus_, GetObjectProxy(kTestServiceName,
- dbus::ObjectPath(kTestPath)))
+ EXPECT_CALL(*bus_,
+ GetObjectProxy(kTestServiceName, dbus::ObjectPath(kTestPath)))
.WillRepeatedly(Return(mock_object_proxy_.get()));
int def_timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT;
EXPECT_CALL(*mock_object_proxy_,
@@ -53,9 +53,7 @@
.WillRepeatedly(Invoke(this, &DBusMethodInvokerTest::CreateResponse));
}
- void TearDown() override {
- bus_ = nullptr;
- }
+ void TearDown() override { bus_ = nullptr; }
Response* CreateResponse(dbus::MethodCall* method_call,
int timeout_ms,
@@ -110,10 +108,8 @@
TEST_F(DBusMethodInvokerTest, TestFailure) {
chromeos::ErrorPtr error;
std::unique_ptr<dbus::Response> response =
- chromeos::dbus_utils::CallMethodAndBlock(mock_object_proxy_.get(),
- kTestInterface,
- kTestMethod2,
- &error);
+ chromeos::dbus_utils::CallMethodAndBlock(
+ mock_object_proxy_.get(), kTestInterface, kTestMethod2, &error);
EXPECT_EQ(nullptr, response.get());
EXPECT_EQ(chromeos::errors::dbus::kDomain, error->GetDomain());
EXPECT_EQ("org.MyError", error->GetCode());
@@ -123,7 +119,7 @@
//////////////////////////////////////////////////////////////////////////////
// Asynchronous method invocation support
-class AsyncDBusMethodInvokerTest: public testing::Test {
+class AsyncDBusMethodInvokerTest : public testing::Test {
public:
void SetUp() override {
dbus::Bus::Options options;
@@ -135,19 +131,16 @@
// Use a mock exported object.
mock_object_proxy_ = new dbus::MockObjectProxy(
bus_.get(), kTestServiceName, dbus::ObjectPath(kTestPath));
- EXPECT_CALL(*bus_, GetObjectProxy(kTestServiceName,
- dbus::ObjectPath(kTestPath)))
+ EXPECT_CALL(*bus_,
+ GetObjectProxy(kTestServiceName, dbus::ObjectPath(kTestPath)))
.WillRepeatedly(Return(mock_object_proxy_.get()));
int def_timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT;
EXPECT_CALL(*mock_object_proxy_,
CallMethodWithErrorCallback(_, def_timeout_ms, _, _))
- .WillRepeatedly(Invoke(this,
- &AsyncDBusMethodInvokerTest::HandleCall));
+ .WillRepeatedly(Invoke(this, &AsyncDBusMethodInvokerTest::HandleCall));
}
- void TearDown() override {
- bus_ = nullptr;
- }
+ void TearDown() override { bus_ = nullptr; }
void HandleCall(dbus::MethodCall* method_call,
int timeout_ms,
@@ -179,8 +172,8 @@
}
struct SuccessCallback {
- SuccessCallback(const std::string& in_result,
- int* in_counter) : result(in_result), counter(in_counter) {}
+ SuccessCallback(const std::string& in_result, int* in_counter)
+ : result(in_result), counter(in_counter) {}
explicit SuccessCallback(int* in_counter) : counter(in_counter) {}
diff --git a/chromeos/dbus/dbus_method_response.cc b/chromeos/dbus/dbus_method_response.cc
index 6fac1d6..e376a0a 100644
--- a/chromeos/dbus/dbus_method_response.cc
+++ b/chromeos/dbus/dbus_method_response.cc
@@ -11,8 +11,7 @@
DBusMethodResponseBase::DBusMethodResponseBase(dbus::MethodCall* method_call,
ResponseSender sender)
- : sender_(sender),
- method_call_(method_call) {
+ : sender_(sender), method_call_(method_call) {
}
DBusMethodResponseBase::~DBusMethodResponseBase() {
diff --git a/chromeos/dbus/dbus_object.cc b/chromeos/dbus/dbus_object.cc
index db16c7e..4e8cdc2 100644
--- a/chromeos/dbus/dbus_object.cc
+++ b/chromeos/dbus/dbus_object.cc
@@ -20,14 +20,13 @@
DBusInterface::DBusInterface(DBusObject* dbus_object,
const std::string& interface_name)
- : dbus_object_(dbus_object),
- interface_name_(interface_name) {}
+ : dbus_object_(dbus_object), interface_name_(interface_name) {
+}
void DBusInterface::AddProperty(const std::string& property_name,
ExportedPropertyBase* prop_base) {
- dbus_object_->property_set_.RegisterProperty(interface_name_,
- property_name,
- prop_base);
+ dbus_object_->property_set_.RegisterProperty(
+ interface_name_, property_name, prop_base);
}
void DBusInterface::ExportAsync(
@@ -45,8 +44,8 @@
std::string export_error = "Failed exporting " + method_name + " method";
auto export_handler = sequencer->GetExportHandler(
interface_name_, method_name, export_error, true);
- auto method_handler = base::Bind(&DBusInterface::HandleMethodCall,
- base::Unretained(this));
+ auto method_handler =
+ base::Bind(&DBusInterface::HandleMethodCall, base::Unretained(this));
exported_object->ExportMethod(
interface_name_, method_name, method_handler, export_handler);
}
@@ -66,22 +65,20 @@
sequencer->OnAllTasksCompletedCall(actions);
}
-void DBusInterface::HandleMethodCall(
- dbus::MethodCall* method_call,
- ResponseSender sender) {
+void DBusInterface::HandleMethodCall(dbus::MethodCall* method_call,
+ ResponseSender sender) {
std::string method_name = method_call->GetMember();
// Make a local copy of |interface_name_| because calling HandleMethod()
// can potentially kill this interface object...
std::string interface_name = interface_name_;
- VLOG(1) << "Received method call request: "
- << interface_name << "." << method_name
- << "(" << method_call->GetSignature() << ")";
+ VLOG(1) << "Received method call request: " << interface_name << "."
+ << method_name << "(" << method_call->GetSignature() << ")";
auto pair = handlers_.find(method_name);
if (pair == handlers_.end()) {
- auto response = dbus::ErrorResponse::FromMethodCall(
- method_call,
- DBUS_ERROR_UNKNOWN_METHOD,
- "Unknown method: " + method_name);
+ auto response =
+ dbus::ErrorResponse::FromMethodCall(method_call,
+ DBUS_ERROR_UNKNOWN_METHOD,
+ "Unknown method: " + method_name);
sender.Run(response.Pass());
return;
}
@@ -92,8 +89,8 @@
void DBusInterface::AddHandlerImpl(
const std::string& method_name,
std::unique_ptr<DBusInterfaceMethodHandlerInterface> handler) {
- VLOG(1) << "Declaring method handler: "
- << interface_name_ << "." << method_name;
+ VLOG(1) << "Declaring method handler: " << interface_name_ << "."
+ << method_name;
auto res = handlers_.insert(std::make_pair(method_name, std::move(handler)));
CHECK(res.second) << "Method '" << method_name << "' already exists";
}
@@ -101,21 +98,18 @@
void DBusInterface::AddSignalImpl(
const std::string& signal_name,
const std::shared_ptr<DBusSignalBase>& signal) {
- VLOG(1) << "Declaring a signal sink: "
- << interface_name_ << "." << signal_name;
+ VLOG(1) << "Declaring a signal sink: " << interface_name_ << "."
+ << signal_name;
CHECK(signals_.insert(std::make_pair(signal_name, signal)).second)
<< "The signal '" << signal_name << "' is already registered";
}
-
///////////////////////////////////////////////////////////////////////////////
DBusObject::DBusObject(ExportedObjectManager* object_manager,
const scoped_refptr<dbus::Bus>& bus,
const dbus::ObjectPath& object_path)
- : property_set_(bus.get()),
- bus_(bus),
- object_path_(object_path) {
+ : property_set_(bus.get()), bus_(bus), object_path_(object_path) {
if (object_manager)
object_manager_ = object_manager->AsWeakPtr();
}
@@ -139,21 +133,21 @@
// Interface doesn't exist yet. Create one...
std::unique_ptr<DBusInterface> new_itf(
new DBusInterface(this, interface_name));
- iter = interfaces_.insert(
- std::make_pair(interface_name, std::move(new_itf))).first;
+ iter = interfaces_.insert(std::make_pair(interface_name,
+ std::move(new_itf))).first;
}
return iter->second.get();
}
DBusInterface* DBusObject::FindInterface(
- const std::string& interface_name) const {
+ const std::string& interface_name) const {
auto itf_iter = interfaces_.find(interface_name);
return (itf_iter == interfaces_.end()) ? nullptr : itf_iter->second.get();
}
void DBusObject::RegisterAsync(
const AsyncEventSequencer::CompletionAction& completion_callback) {
- VLOG(1) << "Registering D-Bus object '"<< object_path_.value() << "'.";
+ VLOG(1) << "Registering D-Bus object '" << object_path_.value() << "'.";
CHECK(exported_object_ == nullptr) << "Object already registered.";
scoped_refptr<AsyncEventSequencer> sequencer(new AsyncEventSequencer());
exported_object_ = bus_->GetExportedObject(object_path_);
diff --git a/chromeos/dbus/dbus_object.h b/chromeos/dbus/dbus_object.h
index 766761f..5701801 100644
--- a/chromeos/dbus/dbus_object.h
+++ b/chromeos/dbus/dbus_object.h
@@ -123,9 +123,8 @@
// Register sync D-Bus method handler for |method_name| as a static
// function.
template<typename R, typename... Args>
- inline void AddSimpleMethodHandler(
- const std::string& method_name,
- R(*handler)(Args...)) {
+ inline void AddSimpleMethodHandler(const std::string& method_name,
+ R(*handler)(Args...)) {
Handler<SimpleDBusInterfaceMethodHandler<R, Args...>>::Add(
this, method_name, base::Bind(handler));
}
@@ -133,20 +132,18 @@
// Register sync D-Bus method handler for |method_name| as a class member
// function.
template<typename Instance, typename Class, typename R, typename... Args>
- inline void AddSimpleMethodHandler(
- const std::string& method_name,
- Instance instance,
- R(Class::*handler)(Args...)) {
+ inline void AddSimpleMethodHandler(const std::string& method_name,
+ Instance instance,
+ R(Class::*handler)(Args...)) {
Handler<SimpleDBusInterfaceMethodHandler<R, Args...>>::Add(
this, method_name, base::Bind(handler, instance));
}
// Same as above but for const-method of a class.
template<typename Instance, typename Class, typename R, typename... Args>
- inline void AddSimpleMethodHandler(
- const std::string& method_name,
- Instance instance,
- R(Class::*handler)(Args...) const) {
+ inline void AddSimpleMethodHandler(const std::string& method_name,
+ Instance instance,
+ R(Class::*handler)(Args...) const) {
Handler<SimpleDBusInterfaceMethodHandler<R, Args...>>::Add(
this, method_name, base::Bind(handler, instance));
}
@@ -205,9 +202,8 @@
// Register an async D-Bus method handler for |method_name| as a static
// function.
template<typename Response, typename... Args>
- inline void AddMethodHandler(
- const std::string& method_name,
- void(*handler)(scoped_ptr<Response>, Args...)) {
+ inline void AddMethodHandler(const std::string& method_name,
+ void (*handler)(scoped_ptr<Response>, Args...)) {
static_assert(std::is_base_of<DBusMethodResponseBase, Response>::value,
"Response must be DBusMethodResponse<T...>");
Handler<DBusInterfaceMethodHandler<Response, Args...>>::Add(
@@ -216,7 +212,9 @@
// Register an async D-Bus method handler for |method_name| as a class member
// function.
- template<typename Response, typename Instance, typename Class,
+ template<typename Response,
+ typename Instance,
+ typename Class,
typename... Args>
inline void AddMethodHandler(
const std::string& method_name,
@@ -229,7 +227,9 @@
}
// Same as above but for const-method of a class.
- template<typename Response, typename Instance, typename Class,
+ template<typename Response,
+ typename Instance,
+ typename Class,
typename... Args>
inline void AddMethodHandler(
const std::string& method_name,
@@ -283,9 +283,8 @@
template<typename DBusSignalType>
inline std::weak_ptr<DBusSignalType> RegisterSignalOfType(
const std::string& signal_name) {
- auto signal = std::make_shared<DBusSignalType>(dbus_object_,
- interface_name_,
- signal_name);
+ auto signal = std::make_shared<DBusSignalType>(
+ dbus_object_, interface_name_, signal_name);
AddSignalImpl(signal_name, signal);
return signal;
}
@@ -351,8 +350,8 @@
const AsyncEventSequencer::CompletionAction& completion_callback);
// Method registration map.
- std::map<std::string,
- std::unique_ptr<DBusInterfaceMethodHandlerInterface>> handlers_;
+ std::map<std::string, std::unique_ptr<DBusInterfaceMethodHandlerInterface>>
+ handlers_;
// Signal registration map.
std::map<std::string, std::shared_ptr<DBusSignalBase>> signals_;
diff --git a/chromeos/dbus/dbus_object_internal_impl.h b/chromeos/dbus/dbus_object_internal_impl.h
index 925ce04..22df883 100644
--- a/chromeos/dbus/dbus_object_internal_impl.h
+++ b/chromeos/dbus/dbus_object_internal_impl.h
@@ -86,9 +86,8 @@
ErrorPtr param_reader_error;
dbus::MessageReader reader(method_call);
// The handler is expected a return value, don't allow output parameters.
- if (!DBusParamReader<false, Args...>::Invoke(invoke_callback,
- &reader,
- ¶m_reader_error)) {
+ if (!DBusParamReader<false, Args...>::Invoke(
+ invoke_callback, &reader, ¶m_reader_error)) {
// Error parsing method arguments.
method_response.ReplyWithError(param_reader_error.get());
}
@@ -124,9 +123,8 @@
ErrorPtr param_reader_error;
dbus::MessageReader reader(method_call);
- if (!DBusParamReader<true, Args...>::Invoke(invoke_callback,
- &reader,
- ¶m_reader_error)) {
+ if (!DBusParamReader<true, Args...>::Invoke(
+ invoke_callback, &reader, ¶m_reader_error)) {
// Error parsing method arguments.
method_response.ReplyWithError(param_reader_error.get());
}
@@ -156,7 +154,7 @@
// virtual function is invoked.
explicit SimpleDBusInterfaceMethodHandlerWithError(
const base::Callback<bool(ErrorPtr*, Args...)>& handler)
- : handler_(handler) {}
+ : handler_(handler) {}
void HandleMethod(dbus::MethodCall* method_call,
ResponseSender sender) override {
@@ -175,9 +173,8 @@
ErrorPtr param_reader_error;
dbus::MessageReader reader(method_call);
- if (!DBusParamReader<true, Args...>::Invoke(invoke_callback,
- &reader,
- ¶m_reader_error)) {
+ if (!DBusParamReader<true, Args...>::Invoke(
+ invoke_callback, &reader, ¶m_reader_error)) {
// Error parsing method arguments.
method_response.ReplyWithError(param_reader_error.get());
}
@@ -203,7 +200,7 @@
// virtual function is invoked.
explicit DBusInterfaceMethodHandler(
const base::Callback<void(scoped_ptr<Response>, Args...)>& handler)
- : handler_(handler) {}
+ : handler_(handler) {}
// This method forwards the call to |handler_| after extracting the required
// arguments from the DBus message buffer specified in |method_call|.
@@ -217,9 +214,8 @@
ErrorPtr param_reader_error;
dbus::MessageReader reader(method_call);
- if (!DBusParamReader<false, Args...>::Invoke(invoke_callback,
- &reader,
- ¶m_reader_error)) {
+ if (!DBusParamReader<false, Args...>::Invoke(
+ invoke_callback, &reader, ¶m_reader_error)) {
// Error parsing method arguments.
DBusMethodResponseBase method_response(method_call, sender);
method_response.ReplyWithError(param_reader_error.get());
@@ -247,8 +243,7 @@
// virtual function is invoked.
RawDBusInterfaceMethodHandler(
const base::Callback<void(dbus::MethodCall*, ResponseSender)>& handler)
- : handler_(handler) {
- }
+ : handler_(handler) {}
void HandleMethod(dbus::MethodCall* method_call,
ResponseSender sender) override {
diff --git a/chromeos/dbus/dbus_object_unittest.cc b/chromeos/dbus/dbus_object_unittest.cc
index 70c3144..f0b7d55 100644
--- a/chromeos/dbus/dbus_object_unittest.cc
+++ b/chromeos/dbus/dbus_object_unittest.cc
@@ -82,26 +82,27 @@
EXPECT_CALL(*bus_, AssertOnDBusThread()).Times(AnyNumber());
// Use a mock exported object.
const dbus::ObjectPath kMethodsExportedOnPath(std::string("/export"));
- mock_exported_object_ = new dbus::MockExportedObject(
- bus_.get(), kMethodsExportedOnPath);
+ mock_exported_object_ =
+ new dbus::MockExportedObject(bus_.get(), kMethodsExportedOnPath);
EXPECT_CALL(*bus_, GetExportedObject(kMethodsExportedOnPath))
- .Times(AnyNumber()).WillRepeatedly(Return(mock_exported_object_.get()));
- EXPECT_CALL(*mock_exported_object_,
- ExportMethod(_, _, _, _)).Times(AnyNumber());
+ .Times(AnyNumber())
+ .WillRepeatedly(Return(mock_exported_object_.get()));
+ EXPECT_CALL(*mock_exported_object_, ExportMethod(_, _, _, _))
+ .Times(AnyNumber());
EXPECT_CALL(*mock_exported_object_, Unregister()).Times(1);
dbus_object_ = std::unique_ptr<DBusObject>(
new DBusObject(nullptr, bus_, kMethodsExportedOnPath));
DBusInterface* itf1 = dbus_object_->AddOrGetInterface(kTestInterface1);
- itf1->AddSimpleMethodHandler(kTestMethod_Add,
- base::Unretained(&calc_), &Calc::Add);
- itf1->AddSimpleMethodHandler(kTestMethod_Negate,
- base::Unretained(&calc_), &Calc::Negate);
- itf1->AddMethodHandler(kTestMethod_Positive,
- base::Unretained(&calc_), &Calc::Positive);
- itf1->AddSimpleMethodHandler(kTestMethod_AddSubtract,
- base::Unretained(&calc_), &Calc::AddSubtract);
+ itf1->AddSimpleMethodHandler(
+ kTestMethod_Add, base::Unretained(&calc_), &Calc::Add);
+ itf1->AddSimpleMethodHandler(
+ kTestMethod_Negate, base::Unretained(&calc_), &Calc::Negate);
+ itf1->AddMethodHandler(
+ kTestMethod_Positive, base::Unretained(&calc_), &Calc::Positive);
+ itf1->AddSimpleMethodHandler(
+ kTestMethod_AddSubtract, base::Unretained(&calc_), &Calc::AddSubtract);
DBusInterface* itf2 = dbus_object_->AddOrGetInterface(kTestInterface2);
itf2->AddSimpleMethodHandler(kTestMethod_StrLen, StrLen);
itf2->AddSimpleMethodHandlerWithError(kTestMethod_CheckNonEmpty,
diff --git a/chromeos/dbus/dbus_param_reader.h b/chromeos/dbus/dbus_param_reader.h
index 216a222..0ac1c2a 100644
--- a/chromeos/dbus/dbus_param_reader.h
+++ b/chromeos/dbus/dbus_param_reader.h
@@ -72,10 +72,10 @@
// Overload 1: ParamType is not a pointer.
template<typename ParamType, typename CallbackType, typename... Args>
static typename std::enable_if<!std::is_pointer<ParamType>::value, bool>::type
- InvokeHelper(const CallbackType& handler,
- dbus::MessageReader* reader,
- ErrorPtr* error,
- const Args&... args) {
+ InvokeHelper(const CallbackType& handler,
+ dbus::MessageReader* reader,
+ ErrorPtr* error,
+ const Args&... args) {
if (!reader->HasMoreData()) {
Error::AddTo(error, FROM_HERE, errors::dbus::kDomain,
DBUS_ERROR_INVALID_ARGS,
diff --git a/chromeos/dbus/dbus_param_reader_unittest.cc b/chromeos/dbus/dbus_param_reader_unittest.cc
index db0a975..d498516 100644
--- a/chromeos/dbus/dbus_param_reader_unittest.cc
+++ b/chromeos/dbus/dbus_param_reader_unittest.cc
@@ -35,8 +35,8 @@
EXPECT_EQ(123, param1);
called = true;
};
- EXPECT_TRUE((DBusParamReader<false, int>::Invoke(callback, &reader,
- nullptr)));
+ EXPECT_TRUE(
+ (DBusParamReader<false, int>::Invoke(callback, &reader, nullptr)));
EXPECT_TRUE(called);
}
@@ -76,8 +76,8 @@
called = true;
};
ErrorPtr error;
- EXPECT_FALSE((DBusParamReader<false, bool, int>::Invoke(callback, &reader,
- &error)));
+ EXPECT_FALSE(
+ (DBusParamReader<false, bool, int>::Invoke(callback, &reader, &error)));
EXPECT_FALSE(called);
EXPECT_EQ(errors::dbus::kDomain, error->GetDomain());
EXPECT_EQ(DBUS_ERROR_INVALID_ARGS, error->GetCode());
@@ -96,8 +96,8 @@
called = true;
};
ErrorPtr error;
- EXPECT_FALSE((DBusParamReader<false, bool, int>::Invoke(callback, &reader,
- &error)));
+ EXPECT_FALSE(
+ (DBusParamReader<false, bool, int>::Invoke(callback, &reader, &error)));
EXPECT_FALSE(called);
EXPECT_EQ(errors::dbus::kDomain, error->GetDomain());
EXPECT_EQ(DBUS_ERROR_INVALID_ARGS, error->GetCode());
@@ -117,8 +117,8 @@
called = true;
};
ErrorPtr error;
- EXPECT_FALSE((DBusParamReader<false, bool, double>::Invoke(callback, &reader,
- &error)));
+ EXPECT_FALSE((
+ DBusParamReader<false, bool, double>::Invoke(callback, &reader, &error)));
EXPECT_FALSE(called);
EXPECT_EQ(errors::dbus::kDomain, error->GetDomain());
EXPECT_EQ(DBUS_ERROR_INVALID_ARGS, error->GetCode());
@@ -133,8 +133,8 @@
EXPECT_EQ(0, *param1);
called = true;
};
- EXPECT_TRUE((DBusParamReader<true, int*>::Invoke(callback, &reader,
- nullptr)));
+ EXPECT_TRUE(
+ (DBusParamReader<true, int*>::Invoke(callback, &reader, nullptr)));
EXPECT_TRUE(called);
}
@@ -149,8 +149,8 @@
EXPECT_DOUBLE_EQ(0.0, *param2);
called = true;
};
- EXPECT_TRUE((DBusParamReader<true, int, double*>::Invoke(callback, &reader,
- nullptr)));
+ EXPECT_TRUE((
+ DBusParamReader<true, int, double*>::Invoke(callback, &reader, nullptr)));
EXPECT_TRUE(called);
}
@@ -165,8 +165,8 @@
EXPECT_EQ(123, param2);
called = true;
};
- EXPECT_TRUE((DBusParamReader<true, double*, int>::Invoke(callback, &reader,
- nullptr)));
+ EXPECT_TRUE((
+ DBusParamReader<true, double*, int>::Invoke(callback, &reader, nullptr)));
EXPECT_TRUE(called);
}
@@ -194,9 +194,13 @@
EXPECT_FALSE(*p6);
called = true;
};
- EXPECT_TRUE((DBusParamReader<true, bool, std::string*, int, int*,
- VariantDictionary, bool*>::Invoke(
- callback, &reader, nullptr)));
+ EXPECT_TRUE((DBusParamReader<true,
+ bool,
+ std::string*,
+ int,
+ int*,
+ VariantDictionary,
+ bool*>::Invoke(callback, &reader, nullptr)));
EXPECT_TRUE(called);
}
@@ -216,9 +220,8 @@
called = true;
};
ErrorPtr error;
- EXPECT_FALSE((DBusParamReader<true, bool, int, int*>::Invoke(callback,
- &reader,
- &error)));
+ EXPECT_FALSE((DBusParamReader<true, bool, int, int*>::Invoke(
+ callback, &reader, &error)));
EXPECT_FALSE(called);
EXPECT_EQ(errors::dbus::kDomain, error->GetDomain());
EXPECT_EQ(DBUS_ERROR_INVALID_ARGS, error->GetCode());
@@ -238,9 +241,8 @@
called = true;
};
ErrorPtr error;
- EXPECT_FALSE((DBusParamReader<true, bool, int, int*>::Invoke(callback,
- &reader,
- &error)));
+ EXPECT_FALSE((DBusParamReader<true, bool, int, int*>::Invoke(
+ callback, &reader, &error)));
EXPECT_FALSE(called);
EXPECT_EQ(errors::dbus::kDomain, error->GetDomain());
EXPECT_EQ(DBUS_ERROR_INVALID_ARGS, error->GetCode());
diff --git a/chromeos/dbus/dbus_param_writer_unittest.cc b/chromeos/dbus/dbus_param_writer_unittest.cc
index cdedf5e..37c3f6f 100644
--- a/chromeos/dbus/dbus_param_writer_unittest.cc
+++ b/chromeos/dbus/dbus_param_writer_unittest.cc
@@ -109,10 +109,8 @@
int32_t int_value_in{8};
Any variant_value_in{8.5};
bool bool_value_in{true};
- DBusParamWriter::AppendDBusOutParams(&writer,
- &int_value_in,
- &variant_value_in,
- &bool_value_in);
+ DBusParamWriter::AppendDBusOutParams(
+ &writer, &int_value_in, &variant_value_in, &bool_value_in);
EXPECT_EQ("ivb", message->GetSignature());
int32_t int_value = 0;
@@ -170,14 +168,8 @@
int32_t int_value_in{8};
Any variant_value_in{7.5};
bool bool_value_in{true};
- DBusParamWriter::AppendDBusOutParams(&writer,
- 0,
- &int_value_in,
- 1,
- &variant_value_in,
- 2,
- &bool_value_in,
- 3);
+ DBusParamWriter::AppendDBusOutParams(
+ &writer, 0, &int_value_in, 1, &variant_value_in, 2, &bool_value_in, 3);
EXPECT_EQ("ivb", message->GetSignature());
int32_t int_value = 0;
diff --git a/chromeos/dbus/dbus_property.h b/chromeos/dbus/dbus_property.h
index e761033..48074a0 100644
--- a/chromeos/dbus/dbus_property.h
+++ b/chromeos/dbus/dbus_property.h
@@ -16,7 +16,7 @@
// This class is pretty much a copy of dbus::Property<T> from dbus/property.h
// except that it provides the implementations for PopValueFromReader and
// AppendSetValueToWriter.
-template <class T>
+template<class T>
class Property : public dbus::PropertyBase {
public:
Property() = default;
diff --git a/chromeos/dbus/dbus_signal.cc b/chromeos/dbus/dbus_signal.cc
index abddd61..b4e12d3 100644
--- a/chromeos/dbus/dbus_signal.cc
+++ b/chromeos/dbus/dbus_signal.cc
@@ -12,9 +12,9 @@
DBusSignalBase::DBusSignalBase(DBusObject* dbus_object,
const std::string& interface_name,
const std::string& signal_name)
- : interface_name_(interface_name),
- signal_name_(signal_name),
- dbus_object_(dbus_object) {
+ : interface_name_(interface_name),
+ signal_name_(signal_name),
+ dbus_object_(dbus_object) {
}
bool DBusSignalBase::SendSignal(dbus::Signal* signal) const {
diff --git a/chromeos/dbus/dbus_signal_handler.h b/chromeos/dbus/dbus_signal_handler.h
index 651198d..13a2b82 100644
--- a/chromeos/dbus/dbus_signal_handler.h
+++ b/chromeos/dbus/dbus_signal_handler.h
@@ -51,8 +51,8 @@
// |signal_callback|.
auto dbus_signal_callback = [signal_callback_wrapper](dbus::Signal* signal) {
dbus::MessageReader reader(signal);
- DBusParamReader<false, Args...>::Invoke(signal_callback_wrapper, &reader,
- nullptr);
+ DBusParamReader<false, Args...>::Invoke(
+ signal_callback_wrapper, &reader, nullptr);
};
// Register our stub handler with D-Bus ObjectProxy.
diff --git a/chromeos/dbus/dbus_signal_handler_unittest.cc b/chromeos/dbus/dbus_signal_handler_unittest.cc
index a195b39..08172ea 100644
--- a/chromeos/dbus/dbus_signal_handler_unittest.cc
+++ b/chromeos/dbus/dbus_signal_handler_unittest.cc
@@ -27,7 +27,7 @@
const char kInterface[] = "org.test.Object.TestInterface";
const char kSignal[] = "TestSignal";
-class DBusSignalHandlerTest: public testing::Test {
+class DBusSignalHandlerTest : public testing::Test {
public:
void SetUp() override {
dbus::Bus::Options options;
@@ -39,14 +39,12 @@
// Use a mock object proxy.
mock_object_proxy_ = new dbus::MockObjectProxy(
bus_.get(), kTestServiceName, dbus::ObjectPath(kTestPath));
- EXPECT_CALL(*bus_, GetObjectProxy(kTestServiceName,
- dbus::ObjectPath(kTestPath)))
+ EXPECT_CALL(*bus_,
+ GetObjectProxy(kTestServiceName, dbus::ObjectPath(kTestPath)))
.WillRepeatedly(Return(mock_object_proxy_.get()));
}
- void TearDown() override {
- bus_ = nullptr;
- }
+ void TearDown() override { bus_ = nullptr; }
protected:
template<typename SignalHandlerSink, typename... Args>
@@ -56,8 +54,11 @@
.WillOnce(SaveArg<2>(&signal_callback));
chromeos::dbus_utils::ConnectToSignal(
- mock_object_proxy_.get(), kInterface, kSignal,
- base::Bind(&SignalHandlerSink::Handler, base::Unretained(sink)), {});
+ mock_object_proxy_.get(),
+ kInterface,
+ kSignal,
+ base::Bind(&SignalHandlerSink::Handler, base::Unretained(sink)),
+ {});
dbus::Signal signal(kInterface, kSignal);
dbus::MessageWriter writer(&signal);
@@ -70,12 +71,11 @@
};
TEST_F(DBusSignalHandlerTest, ConnectToSignal) {
- EXPECT_CALL(*mock_object_proxy_,
- ConnectToSignal(kInterface, kSignal, _, _)).Times(1);
+ EXPECT_CALL(*mock_object_proxy_, ConnectToSignal(kInterface, kSignal, _, _))
+ .Times(1);
- chromeos::dbus_utils::ConnectToSignal(mock_object_proxy_.get(),
- kInterface, kSignal,
- base::Closure{}, {});
+ chromeos::dbus_utils::ConnectToSignal(
+ mock_object_proxy_.get(), kInterface, kSignal, base::Closure{}, {});
}
TEST_F(DBusSignalHandlerTest, CallSignal_3Args) {
diff --git a/chromeos/dbus/exported_object_manager.cc b/chromeos/dbus/exported_object_manager.cc
index 49ebd3e..f952e57 100644
--- a/chromeos/dbus/exported_object_manager.cc
+++ b/chromeos/dbus/exported_object_manager.cc
@@ -17,10 +17,11 @@
ExportedObjectManager::ExportedObjectManager(scoped_refptr<dbus::Bus> bus,
const dbus::ObjectPath& path)
- : bus_(bus), dbus_object_(nullptr, bus, path) {}
+ : bus_(bus), dbus_object_(nullptr, bus, path) {
+}
void ExportedObjectManager::RegisterAsync(
- const AsyncEventSequencer::CompletionAction& completion_callback) {
+ const AsyncEventSequencer::CompletionAction& completion_callback) {
VLOG(1) << "Registering object manager";
bus_->AssertOnOriginThread();
DBusInterface* itf =
@@ -48,14 +49,15 @@
VariantDictionary property_dict;
property_writer.Run(&property_dict);
std::map<std::string, VariantDictionary> interfaces_and_properties{
- {interface_name, property_dict}
+ {interface_name, property_dict}
};
signal_itf_added_.lock()->Send(path, interfaces_and_properties);
registered_objects_[path][interface_name] = property_writer;
}
void ExportedObjectManager::ReleaseInterface(
- const dbus::ObjectPath& path, const std::string& interface_name) {
+ const dbus::ObjectPath& path,
+ const std::string& interface_name) {
bus_->AssertOnOriginThread();
auto interfaces_for_path_itr = registered_objects_.find(path);
CHECK(interfaces_for_path_itr != registered_objects_.end())
@@ -78,7 +80,7 @@
}
ExportedObjectManager::ObjectMap
- ExportedObjectManager::HandleGetManagedObjects() {
+ExportedObjectManager::HandleGetManagedObjects() {
// Implements the GetManagedObjects method:
//
// org.freedesktop.DBus.ObjectManager.GetManagedObjects (
diff --git a/chromeos/dbus/exported_object_manager_unittest.cc b/chromeos/dbus/exported_object_manager_unittest.cc
index 3f3d867..9ae3b20 100644
--- a/chromeos/dbus/exported_object_manager_unittest.cc
+++ b/chromeos/dbus/exported_object_manager_unittest.cc
@@ -51,8 +51,7 @@
}
void VerifyInterfaceClaimSignal(dbus::Signal* signal) {
- EXPECT_EQ(signal->GetInterface(),
- std::string(dbus::kObjectManagerInterface));
+ EXPECT_EQ(signal->GetInterface(), std::string(dbus::kObjectManagerInterface));
EXPECT_EQ(signal->GetMember(),
std::string(dbus::kObjectManagerInterfacesAdded));
// org.freedesktop.DBus.ObjectManager.InterfacesAdded (
@@ -76,8 +75,7 @@
}
void VerifyInterfaceDropSignal(dbus::Signal* signal) {
- EXPECT_EQ(signal->GetInterface(),
- std::string(dbus::kObjectManagerInterface));
+ EXPECT_EQ(signal->GetInterface(), std::string(dbus::kObjectManagerInterface));
EXPECT_EQ(signal->GetMember(),
std::string(dbus::kObjectManagerInterfacesRemoved));
// org.freedesktop.DBus.ObjectManager.InterfacesRemoved (
@@ -97,7 +95,7 @@
} // namespace
-class ExportedObjectManagerTest: public ::testing::Test {
+class ExportedObjectManagerTest : public ::testing::Test {
public:
void SetUp() override {
dbus::Bus::Options options;
@@ -107,12 +105,11 @@
EXPECT_CALL(*bus_, AssertOnOriginThread()).Times(AnyNumber());
EXPECT_CALL(*bus_, AssertOnDBusThread()).Times(AnyNumber());
// Use a mock exported object.
- mock_exported_object_ = new dbus::MockExportedObject(
- bus_.get(), kTestPath);
- EXPECT_CALL(*bus_, GetExportedObject(kTestPath))
- .Times(1).WillOnce(Return(mock_exported_object_.get()));
- EXPECT_CALL(*mock_exported_object_,
- ExportMethod(_, _, _, _)).Times(AnyNumber());
+ mock_exported_object_ = new dbus::MockExportedObject(bus_.get(), kTestPath);
+ EXPECT_CALL(*bus_, GetExportedObject(kTestPath)).Times(1).WillOnce(
+ Return(mock_exported_object_.get()));
+ EXPECT_CALL(*mock_exported_object_, ExportMethod(_, _, _, _))
+ .Times(AnyNumber());
om_.reset(new ExportedObjectManager(bus_.get(), kTestPath));
property_writer_ = base::Bind(&WriteTestPropertyDict);
om_->RegisterAsync(AsyncEventSequencer::GetDefaultCompletionAction());
diff --git a/chromeos/dbus/exported_property_set.cc b/chromeos/dbus/exported_property_set.cc
index de8a4a4..0f7d7cf 100644
--- a/chromeos/dbus/exported_property_set.cc
+++ b/chromeos/dbus/exported_property_set.cc
@@ -19,8 +19,8 @@
namespace dbus_utils {
ExportedPropertySet::ExportedPropertySet(dbus::Bus* bus)
- : bus_(bus),
- weak_ptr_factory_(this) { }
+ : bus_(bus), weak_ptr_factory_(this) {
+}
void ExportedPropertySet::OnPropertiesInterfaceExported(
DBusInterface* prop_interface) {
@@ -46,10 +46,11 @@
CHECK(res.second) << "Property '" << property_name << "' already exists";
// Technically, the property set exists longer than the properties themselves,
// so we could use Unretained here rather than a weak pointer.
- ExportedPropertyBase::OnUpdateCallback cb = base::Bind(
- &ExportedPropertySet::HandlePropertyUpdated,
- weak_ptr_factory_.GetWeakPtr(),
- interface_name, property_name);
+ ExportedPropertyBase::OnUpdateCallback cb =
+ base::Bind(&ExportedPropertySet::HandlePropertyUpdated,
+ weak_ptr_factory_.GetWeakPtr(),
+ interface_name,
+ property_name);
exported_property->SetUpdateCallback(cb);
}
@@ -60,7 +61,7 @@
}
VariantDictionary ExportedPropertySet::GetInterfaceProperties(
- const std::string& interface_name) const {
+ const std::string& interface_name) const {
VariantDictionary properties;
auto property_map_itr = properties_.find(interface_name);
if (property_map_itr != properties_.end()) {
@@ -76,11 +77,10 @@
*dict = GetInterfaceProperties(interface_name);
}
-bool ExportedPropertySet::HandleGet(
- chromeos::ErrorPtr* error,
- const std::string& interface_name,
- const std::string& property_name,
- chromeos::Any* result) {
+bool ExportedPropertySet::HandleGet(chromeos::ErrorPtr* error,
+ const std::string& interface_name,
+ const std::string& property_name,
+ chromeos::Any* result) {
bus_->AssertOnOriginThread();
auto property_map_itr = properties_.find(interface_name);
if (property_map_itr == properties_.end()) {
@@ -105,11 +105,10 @@
return true;
}
-bool ExportedPropertySet::HandleSet(
- chromeos::ErrorPtr* error,
- const std::string& interface_name,
- const std::string& property_name,
- const chromeos::Any& value) {
+bool ExportedPropertySet::HandleSet(chromeos::ErrorPtr* error,
+ const std::string& interface_name,
+ const std::string& property_name,
+ const chromeos::Any& value) {
bus_->AssertOnOriginThread();
auto property_map_itr = properties_.find(interface_name);
if (property_map_itr == properties_.end()) {
diff --git a/chromeos/dbus/exported_property_set.h b/chromeos/dbus/exported_property_set.h
index 530b6ea..5b8dc57 100644
--- a/chromeos/dbus/exported_property_set.h
+++ b/chromeos/dbus/exported_property_set.h
@@ -113,20 +113,18 @@
// D-Bus methods for org.freedesktop.DBus.Properties interface.
VariantDictionary HandleGetAll(const std::string& interface_name);
- bool HandleGet(
- chromeos::ErrorPtr* error,
- const std::string& interface_name,
- const std::string& property_name,
- chromeos::Any* result);
+ bool HandleGet(chromeos::ErrorPtr* error,
+ const std::string& interface_name,
+ const std::string& property_name,
+ chromeos::Any* result);
// While Properties.Set has a handler to complete the interface, we don't
// support writable properties. This is almost a feature, since bindings for
// many languages don't support errors coming back from invalid writes.
// Instead, use setters in exposed interfaces.
- bool HandleSet(
- chromeos::ErrorPtr* error,
- const std::string& interface_name,
- const std::string& property_name,
- const chromeos::Any& value);
+ bool HandleSet(chromeos::ErrorPtr* error,
+ const std::string& interface_name,
+ const std::string& property_name,
+ const chromeos::Any& value);
// Returns a string-to-variant map of all the properties for the given
// interface and their values.
VariantDictionary GetInterfaceProperties(
@@ -136,9 +134,8 @@
// Used to write the dictionary of string->variant to a message.
// This dictionary represents the property name/value pairs for the
// given interface.
- CHROMEOS_PRIVATE void WritePropertiesToDict(
- const std::string& interface_name,
- VariantDictionary* dict);
+ CHROMEOS_PRIVATE void WritePropertiesToDict(const std::string& interface_name,
+ VariantDictionary* dict);
CHROMEOS_PRIVATE void HandlePropertyUpdated(
const std::string& interface_name,
const std::string& property_name,
@@ -146,8 +143,8 @@
dbus::Bus* bus_; // weak; owned by outer DBusObject containing this object.
// This is a map from interface name -> property name -> pointer to property.
- std::map<std::string,
- std::map<std::string, ExportedPropertyBase*>> properties_;
+ std::map<std::string, std::map<std::string, ExportedPropertyBase*>>
+ properties_;
// D-Bus callbacks may last longer the property set exporting those methods.
base::WeakPtrFactory<ExportedPropertySet> weak_ptr_factory_;
@@ -162,7 +159,7 @@
DISALLOW_COPY_AND_ASSIGN(ExportedPropertySet);
};
-template <typename T>
+template<typename T>
class ExportedProperty : public ExportedPropertyBase {
public:
ExportedProperty() = default;
@@ -173,7 +170,7 @@
// Set the value exposed to remote applications. This triggers notifications
// of changes over the Properties interface.
- void SetValue(const T& new_value) {
+ void SetValue(const T& new_value) {
if (value_ != new_value) {
value_ = new_value;
this->NotifyPropertyChanged();
diff --git a/chromeos/dbus/exported_property_set_unittest.cc b/chromeos/dbus/exported_property_set_unittest.cc
index 5e3965d..5ecd08b 100644
--- a/chromeos/dbus/exported_property_set_unittest.cc
+++ b/chromeos/dbus/exported_property_set_unittest.cc
@@ -116,8 +116,8 @@
EXPECT_CALL(*bus_, AssertOnOriginThread()).Times(AnyNumber());
EXPECT_CALL(*bus_, AssertOnDBusThread()).Times(AnyNumber());
// Use a mock exported object.
- mock_exported_object_ = new dbus::MockExportedObject(
- bus_.get(), kMethodsExportedOnPath);
+ mock_exported_object_ =
+ new dbus::MockExportedObject(bus_.get(), kMethodsExportedOnPath);
EXPECT_CALL(*bus_, GetExportedObject(kMethodsExportedOnPath))
.Times(1).WillOnce(Return(mock_exported_object_.get()));
@@ -137,7 +137,8 @@
}
std::unique_ptr<dbus::Response> GetPropertyOnInterface(
- const std::string& interface_name, const std::string& property_name) {
+ const std::string& interface_name,
+ const std::string& property_name) {
dbus::MethodCall method_call(dbus::kPropertiesInterface,
dbus::kPropertiesGet);
method_call.SetSerial(123);
@@ -167,7 +168,7 @@
scoped_ptr<Properties> p_;
};
-template <typename T>
+template<typename T>
class PropertyValidatorObserver {
public:
PropertyValidatorObserver()
@@ -180,7 +181,7 @@
bool(chromeos::ErrorPtr* error, const T& value));
const base::Callback<bool(chromeos::ErrorPtr*, const T&)>&
- validate_property_callback() const {
+ validate_property_callback() const {
return validate_property_callback_;
}
@@ -222,8 +223,8 @@
}
TEST_F(ExportedPropertySetTest, GetAllInvalidInterface) {
- dbus::MethodCall method_call(
- dbus::kPropertiesInterface, dbus::kPropertiesGetAll);
+ dbus::MethodCall method_call(dbus::kPropertiesInterface,
+ dbus::kPropertiesGetAll);
method_call.SetSerial(123);
dbus::MessageWriter writer(&method_call);
writer.AppendString("org.chromium.BadInterface");
@@ -248,8 +249,8 @@
}
TEST_F(ExportedPropertySetTest, GetAllCorrectness) {
- dbus::MethodCall method_call(
- dbus::kPropertiesInterface, dbus::kPropertiesGetAll);
+ dbus::MethodCall method_call(dbus::kPropertiesInterface,
+ dbus::kPropertiesGetAll);
method_call.SetSerial(123);
dbus::MessageWriter writer(&method_call);
writer.AppendString(kTestInterface2);
@@ -459,34 +460,30 @@
}
TEST_F(ExportedPropertySetTest, SetInvalidInterface) {
- auto response = SetPropertyOnInterface("BadInterfaceName",
- kStringPropName,
- chromeos::Any(kTestString));
+ auto response = SetPropertyOnInterface(
+ "BadInterfaceName", kStringPropName, chromeos::Any(kTestString));
ASSERT_EQ(dbus::Message::MESSAGE_ERROR, response->GetMessageType());
ASSERT_EQ(DBUS_ERROR_UNKNOWN_INTERFACE, response->GetErrorName());
}
TEST_F(ExportedPropertySetTest, SetBadPropertyName) {
- auto response = SetPropertyOnInterface(kTestInterface3,
- "IAmNotAProperty",
- chromeos::Any(kTestString));
+ auto response = SetPropertyOnInterface(
+ kTestInterface3, "IAmNotAProperty", chromeos::Any(kTestString));
ASSERT_EQ(dbus::Message::MESSAGE_ERROR, response->GetMessageType());
ASSERT_EQ(DBUS_ERROR_UNKNOWN_PROPERTY, response->GetErrorName());
}
TEST_F(ExportedPropertySetTest, SetFailsWithReadOnlyProperty) {
- auto response = SetPropertyOnInterface(kTestInterface3,
- kStringPropName,
- chromeos::Any(kTestString));
+ auto response = SetPropertyOnInterface(
+ kTestInterface3, kStringPropName, chromeos::Any(kTestString));
ASSERT_EQ(dbus::Message::MESSAGE_ERROR, response->GetMessageType());
ASSERT_EQ(DBUS_ERROR_PROPERTY_READ_ONLY, response->GetErrorName());
}
TEST_F(ExportedPropertySetTest, SetFailsWithMismatchedValueType) {
p_->string_prop_.SetAccessMode(ExportedPropertyBase::Access::kReadWrite);
- auto response = SetPropertyOnInterface(kTestInterface3,
- kStringPropName,
- chromeos::Any(true));
+ auto response = SetPropertyOnInterface(
+ kTestInterface3, kStringPropName, chromeos::Any(true));
ASSERT_EQ(dbus::Message::MESSAGE_ERROR, response->GetMessageType());
ASSERT_EQ(DBUS_ERROR_INVALID_ARGS, response->GetErrorName());
}
@@ -499,7 +496,7 @@
errors::dbus::kDomain,
DBUS_ERROR_INVALID_ARGS,
"Invalid value");
- return false;
+ return false;
}
} // namespace
@@ -514,9 +511,8 @@
FROM_HERE, errors::dbus::kDomain, DBUS_ERROR_INVALID_ARGS, "");
EXPECT_CALL(property_validator, ValidateProperty(_, kTestString))
.WillOnce(Invoke(SetInvalidProperty));
- auto response = SetPropertyOnInterface(kTestInterface3,
- kStringPropName,
- chromeos::Any(kTestString));
+ auto response = SetPropertyOnInterface(
+ kTestInterface3, kStringPropName, chromeos::Any(kTestString));
ASSERT_EQ(dbus::Message::MESSAGE_ERROR, response->GetMessageType());
ASSERT_EQ(DBUS_ERROR_INVALID_ARGS, response->GetErrorName());
}
@@ -529,9 +525,8 @@
EXPECT_CALL(property_validator, ValidateProperty(_, kTestString))
.WillOnce(Return(true));
- auto response = SetPropertyOnInterface(kTestInterface3,
- kStringPropName,
- chromeos::Any(kTestString));
+ auto response = SetPropertyOnInterface(
+ kTestInterface3, kStringPropName, chromeos::Any(kTestString));
ASSERT_NE(dbus::Message::MESSAGE_ERROR, response->GetMessageType());
ASSERT_EQ(kTestString, p_->string_prop_.value());
}
@@ -546,18 +541,16 @@
// No need to validate the value if it is the same as the current one.
EXPECT_CALL(property_validator, ValidateProperty(_, _)).Times(0);
- auto response = SetPropertyOnInterface(kTestInterface3,
- kStringPropName,
- chromeos::Any(kTestString));
+ auto response = SetPropertyOnInterface(
+ kTestInterface3, kStringPropName, chromeos::Any(kTestString));
ASSERT_NE(dbus::Message::MESSAGE_ERROR, response->GetMessageType());
ASSERT_EQ(kTestString, p_->string_prop_.value());
}
TEST_F(ExportedPropertySetTest, SetWorksWithoutValidator) {
p_->string_prop_.SetAccessMode(ExportedPropertyBase::Access::kReadWrite);
- auto response = SetPropertyOnInterface(kTestInterface3,
- kStringPropName,
- chromeos::Any(kTestString));
+ auto response = SetPropertyOnInterface(
+ kTestInterface3, kStringPropName, chromeos::Any(kTestString));
ASSERT_NE(dbus::Message::MESSAGE_ERROR, response->GetMessageType());
ASSERT_EQ(kTestString, p_->string_prop_.value());
}
diff --git a/chromeos/dbus/mock_dbus_object.h b/chromeos/dbus/mock_dbus_object.h
index 2f4d57e..7d0d663 100644
--- a/chromeos/dbus/mock_dbus_object.h
+++ b/chromeos/dbus/mock_dbus_object.h
@@ -19,7 +19,7 @@
MockDBusObject(ExportedObjectManager* object_manager,
const scoped_refptr<dbus::Bus>& bus,
const dbus::ObjectPath& object_path)
- : DBusObject(object_manager, bus, object_path) {}
+ : DBusObject(object_manager, bus, object_path) {}
virtual ~MockDBusObject() = default;
MOCK_METHOD1(RegisterAsync,
diff --git a/chromeos/dbus/utils.cc b/chromeos/dbus/utils.cc
index db3b151..aa23acf 100644
--- a/chromeos/dbus/utils.cc
+++ b/chromeos/dbus/utils.cc
@@ -19,8 +19,8 @@
dbus::MethodCall* method_call,
const std::string& error_name,
const std::string& error_message) {
- auto resp = dbus::ErrorResponse::FromMethodCall(method_call, error_name,
- error_message);
+ auto resp = dbus::ErrorResponse::FromMethodCall(
+ method_call, error_name, error_message);
return std::unique_ptr<dbus::Response>(resp.release());
}
@@ -44,8 +44,8 @@
// Format error string as "domain/code:message".
if (!error_message.empty())
error_message += ';';
- error_message += error->GetDomain() + '/' + error->GetCode() + ':' +
- error->GetMessage();
+ error_message +=
+ error->GetDomain() + '/' + error->GetCode() + ':' + error->GetMessage();
error = error->GetInnerError();
}
return CreateDBusErrorResponse(method_call, error_name, error_message);
@@ -60,8 +60,7 @@
// Each part should be in format of "domain/code:message"
size_t slash_pos = part.find('/');
size_t colon_pos = part.find(':');
- if (slash_pos != std::string::npos &&
- colon_pos != std::string::npos &&
+ if (slash_pos != std::string::npos && colon_pos != std::string::npos &&
slash_pos < colon_pos) {
// If we have both '/' and ':' and in proper order, then we have a
// correctly encoded error object.
@@ -70,8 +69,7 @@
std::string message = part.substr(colon_pos + 1);
errors.emplace_back(domain, code, message);
} else if (slash_pos == std::string::npos &&
- colon_pos == std::string::npos &&
- errors.empty()) {
+ colon_pos == std::string::npos && errors.empty()) {
// If we don't have both '/' and ':' and this is the first error object,
// then we had a D-Bus error at the top of the error chain.
errors.emplace_back(errors::dbus::kDomain, dbus_error_name, part);
@@ -80,17 +78,16 @@
// not generated by GetDBusError(). To be safe, stop parsing it
// and return the error as received from D-Bus.
errors.clear(); // Remove any errors accumulated so far.
- errors.emplace_back(errors::dbus::kDomain,
- dbus_error_name,
- dbus_error_message);
+ errors.emplace_back(
+ errors::dbus::kDomain, dbus_error_name, dbus_error_message);
break;
}
}
// Go backwards and add the parsed errors to the error chain.
for (auto it = errors.crbegin(); it != errors.crend(); ++it) {
- Error::AddTo(error, FROM_HERE,
- std::get<0>(*it), std::get<1>(*it), std::get<2>(*it));
+ Error::AddTo(
+ error, FROM_HERE, std::get<0>(*it), std::get<1>(*it), std::get<2>(*it));
}
}
diff --git a/chromeos/errors/error.cc b/chromeos/errors/error.cc
index 1e7d3a6..86323a0 100644
--- a/chromeos/errors/error.cc
+++ b/chromeos/errors/error.cc
@@ -19,13 +19,10 @@
// the current error location with the location passed in to the Error object.
// This way the log will contain the actual location of the error, and not
// as if it always comes from chromeos/errors/error.cc(22).
- logging::LogMessage(location.file_name(),
- location.line_number(),
- logging::LOG_ERROR).stream()
+ logging::LogMessage(
+ location.file_name(), location.line_number(), logging::LOG_ERROR).stream()
<< location.function_name() << "(...): "
- << "Domain=" << domain
- << ", Code=" << code
- << ", Message=" << message;
+ << "Domain=" << domain << ", Code=" << code << ", Message=" << message;
}
} // anonymous namespace
@@ -42,8 +39,8 @@
const std::string& message,
ErrorPtr inner_error) {
LogError(location, domain, code, message);
- return ErrorPtr(new Error(location, domain, code, message,
- std::move(inner_error)));
+ return ErrorPtr(
+ new Error(location, domain, code, message, std::move(inner_error)));
}
void Error::AddTo(ErrorPtr* error,
@@ -64,7 +61,8 @@
const tracked_objects::Location& location,
const std::string& domain,
const std::string& code,
- const char* format, ...) {
+ const char* format,
+ ...) {
va_list ap;
va_start(ap, format);
std::string message = base::StringPrintV(format, ap);
@@ -91,9 +89,12 @@
const std::string& domain,
const std::string& code,
const std::string& message,
- ErrorPtr inner_error) :
- domain_(domain), code_(code), message_(message), location_(location),
- inner_error_(std::move(inner_error)) {
+ ErrorPtr inner_error)
+ : domain_(domain),
+ code_(code),
+ message_(message),
+ location_(location),
+ inner_error_(std::move(inner_error)) {
}
const Error* Error::FindErrorOfDomain(const Error* error_chain_start,
diff --git a/chromeos/errors/error.h b/chromeos/errors/error.h
index 5f7b0b1..f3e5a8d 100644
--- a/chromeos/errors/error.h
+++ b/chromeos/errors/error.h
@@ -46,7 +46,8 @@
const tracked_objects::Location& location,
const std::string& domain,
const std::string& code,
- const char* format, ...) PRINTF_FORMAT(5, 6);
+ const char* format,
+ ...) PRINTF_FORMAT(5, 6);
// Returns the error domain, code and message
const std::string& GetDomain() const { return domain_; }
diff --git a/chromeos/errors/error_unittest.cc b/chromeos/errors/error_unittest.cc
index 3216d58..e256ead 100644
--- a/chromeos/errors/error_unittest.cc
+++ b/chromeos/errors/error_unittest.cc
@@ -11,8 +11,10 @@
namespace {
chromeos::ErrorPtr GenerateNetworkError() {
- tracked_objects::Location loc("GenerateNetworkError", "error_unittest.cc",
- 15, ::tracked_objects::GetProgramCounter());
+ tracked_objects::Location loc("GenerateNetworkError",
+ "error_unittest.cc",
+ 15,
+ ::tracked_objects::GetProgramCounter());
return Error::Create(loc, "network", "not_found", "Resource not found");
}
diff --git a/chromeos/file_utils.cc b/chromeos/file_utils.cc
index 637fa50..9d3bd53 100644
--- a/chromeos/file_utils.cc
+++ b/chromeos/file_utils.cc
@@ -67,8 +67,7 @@
if (scoped_fd != -1) {
struct stat file_stat;
if (fstat(scoped_fd.get(), &file_stat) != -1 &&
- S_ISREG(file_stat.st_mode) &&
- file_stat.st_uid == uid &&
+ S_ISREG(file_stat.st_mode) && file_stat.st_uid == uid &&
file_stat.st_gid == gid) {
return kRegularFile;
}
diff --git a/chromeos/file_utils_unittest.cc b/chromeos/file_utils_unittest.cc
index 9ad03b3..96a5801 100644
--- a/chromeos/file_utils_unittest.cc
+++ b/chromeos/file_utils_unittest.cc
@@ -52,8 +52,8 @@
namespace {
enum {
- kPermissions600 = base::FILE_PERMISSION_READ_BY_USER |
- base::FILE_PERMISSION_WRITE_BY_USER,
+ kPermissions600 =
+ base::FILE_PERMISSION_READ_BY_USER | base::FILE_PERMISSION_WRITE_BY_USER,
kPermissions700 = base::FILE_PERMISSION_USER_MASK,
kPermissions777 = base::FILE_PERMISSION_MASK
};
diff --git a/chromeos/flag_helper.cc b/chromeos/flag_helper.cc
index d66e3b7..bdc0880 100644
--- a/chromeos/flag_helper.cc
+++ b/chromeos/flag_helper.cc
@@ -30,7 +30,7 @@
class HelpFlag : public chromeos::Flag {
public:
- HelpFlag() : Flag("help", "false", "Show this help message", true) { }
+ HelpFlag() : Flag("help", "false", "Show this help message", true) {}
bool SetValue(const std::string& value) override { return true; };
const char* GetType() const override { return "bool"; }
@@ -227,9 +227,8 @@
error_code = EX_DATAERR;
}
} else {
- base::StringAppendF(&error_msg,
- "ERROR: unknown command line flag '%s'\n",
- key.c_str());
+ base::StringAppendF(
+ &error_msg, "ERROR: unknown command line flag '%s'\n", key.c_str());
error_code = EX_USAGE;
}
}
diff --git a/chromeos/flag_helper.h b/chromeos/flag_helper.h
index 1232b5a..73cd301 100644
--- a/chromeos/flag_helper.h
+++ b/chromeos/flag_helper.h
@@ -183,44 +183,34 @@
// set bool flags to false. Creating the FLAGS_noxxxx variables here
// will also ensure a compiler error will be thrown if another flag
// is created with a conflicting name.
-#define DEFINE_type(type, classtype, name, value, help) \
- type FLAGS_##name = value; \
- chromeos::FlagHelper::GetInstance()->AddFlag( \
- std::unique_ptr<chromeos::Flag>( \
+#define DEFINE_type(type, classtype, name, value, help) \
+ type FLAGS_##name = value; \
+ chromeos::FlagHelper::GetInstance()->AddFlag( \
+ std::unique_ptr<chromeos::Flag>( \
new chromeos::classtype(#name, &FLAGS_##name, #value, help, true)));
#define DEFINE_int32(name, value, help) \
- DEFINE_type(int, Int32Flag, name, value, help)
+ DEFINE_type(int, Int32Flag, name, value, help)
#define DEFINE_int64(name, value, help) \
- DEFINE_type(int64_t, Int64Flag, name, value, help)
+ DEFINE_type(int64_t, Int64Flag, name, value, help)
#define DEFINE_uint64(name, value, help) \
- DEFINE_type(uint64_t, UInt64Flag, name, value, help)
+ DEFINE_type(uint64_t, UInt64Flag, name, value, help)
#define DEFINE_double(name, value, help) \
- DEFINE_type(double, DoubleFlag, name, value, help)
+ DEFINE_type(double, DoubleFlag, name, value, help)
#define DEFINE_string(name, value, help) \
- DEFINE_type(std::string, StringFlag, name, value, help)
+ DEFINE_type(std::string, StringFlag, name, value, help)
// Due to the FLAGS_no##name variables, can't re-use the same DEFINE_type macro
// for defining bool flags
-#define DEFINE_bool(name, value, help) \
- bool FLAGS_##name = value; \
- bool FLAGS_no##name = !value; \
- chromeos::FlagHelper::GetInstance()->AddFlag( \
- std::unique_ptr<chromeos::Flag>( \
- new chromeos::BoolFlag(#name, \
- &FLAGS_##name, \
- &FLAGS_no##name, \
- #value, \
- help, \
- true))); \
- chromeos::FlagHelper::GetInstance()->AddFlag( \
- std::unique_ptr<chromeos::Flag>( \
- new chromeos::BoolFlag("no" #name, \
- &FLAGS_no##name, \
- &FLAGS_##name, \
- #value, \
- help, \
- false)));
+#define DEFINE_bool(name, value, help) \
+ bool FLAGS_##name = value; \
+ bool FLAGS_no##name = !value; \
+ chromeos::FlagHelper::GetInstance()->AddFlag( \
+ std::unique_ptr<chromeos::Flag>(new chromeos::BoolFlag( \
+ #name, &FLAGS_##name, &FLAGS_no##name, #value, help, true))); \
+ chromeos::FlagHelper::GetInstance()->AddFlag( \
+ std::unique_ptr<chromeos::Flag>(new chromeos::BoolFlag( \
+ "no" #name, &FLAGS_no##name, &FLAGS_##name, #value, help, false)));
// The FlagHelper class is a singleton class used for registering command
// line flags and pointers to their associated scoped variables, so that
diff --git a/chromeos/flag_helper_unittest.cc b/chromeos/flag_helper_unittest.cc
index b086df0..1c8261a 100644
--- a/chromeos/flag_helper_unittest.cc
+++ b/chromeos/flag_helper_unittest.cc
@@ -16,10 +16,8 @@
class FlagHelperTest : public ::testing::Test {
public:
- FlagHelperTest() { }
- ~FlagHelperTest() override {
- chromeos::FlagHelper::ResetForTesting();
- }
+ FlagHelperTest() {}
+ ~FlagHelperTest() override { chromeos::FlagHelper::ResetForTesting(); }
};
// Test that the DEFINE_xxxx macros can create the respective variables
@@ -86,12 +84,24 @@
DEFINE_string(string_1, "default", "Test string flag");
DEFINE_string(string_2, "default", "Test string flag");
- const char* argv[] = {"test_program", "--bool1", "--nobool2", "--bool3=true",
- "--bool4=false", "--int32_1=-2147483648", "--int32_2=0",
- "--int32_3=2147483647", "--int64_1=-9223372036854775808", "--int64_2=0",
- "--int64_3=9223372036854775807", "--uint64_1=0",
- "--uint64_2=18446744073709551615", "--double_1=-100.5",
- "--double_2=0", "--double_3=100.5", "--string_1=", "--string_2=value"};
+ const char* argv[] = {"test_program",
+ "--bool1",
+ "--nobool2",
+ "--bool3=true",
+ "--bool4=false",
+ "--int32_1=-2147483648",
+ "--int32_2=0",
+ "--int32_3=2147483647",
+ "--int64_1=-9223372036854775808",
+ "--int64_2=0",
+ "--int64_3=9223372036854775807",
+ "--uint64_1=0",
+ "--uint64_2=18446744073709551615",
+ "--double_1=-100.5",
+ "--double_2=0",
+ "--double_3=100.5",
+ "--string_1=",
+ "--string_2=value"};
CommandLine command_line(arraysize(argv), argv);
chromeos::FlagHelper::GetInstance()->set_command_line_for_testing(
@@ -136,12 +146,22 @@
DEFINE_string(string_1, "default", "Test string flag");
DEFINE_string(string_2, "default", "Test string flag");
- const char* argv[] = {"test_program", "-bool1", "-nobool2",
- "-int32_1=-2147483648", "-int32_2=0", "-int32_3=2147483647",
- "-int64_1=-9223372036854775808", "-int64_2=0",
- "-int64_3=9223372036854775807", "-uint64_1=0",
- "-uint64_2=18446744073709551615", "-double_1=-100.5",
- "-double_2=0", "-double_3=100.5", "-string_1=", "-string_2=value"};
+ const char* argv[] = {"test_program",
+ "-bool1",
+ "-nobool2",
+ "-int32_1=-2147483648",
+ "-int32_2=0",
+ "-int32_3=2147483647",
+ "-int64_1=-9223372036854775808",
+ "-int64_2=0",
+ "-int64_3=9223372036854775807",
+ "-uint64_1=0",
+ "-uint64_2=18446744073709551615",
+ "-double_1=-100.5",
+ "-double_2=0",
+ "-double_3=100.5",
+ "-string_1=",
+ "-string_2=value"};
CommandLine command_line(arraysize(argv), argv);
chromeos::FlagHelper::GetInstance()->set_command_line_for_testing(
@@ -213,24 +233,17 @@
FILE* orig = stdout;
stdout = stderr;
- ASSERT_EXIT(chromeos::FlagHelper::Init(arraysize(argv),
- argv,
- "TestHelpMessage"),
- ::testing::ExitedWithCode(EX_OK),
- "TestHelpMessage\n\n"
- " --bool_1 \\(Test bool flag\\) type: bool default: true\n"
- " --double_1 \\(Test double flag\\) type: double "
- "default: 0\n"
- " --help \\(Show this help message\\) type: bool "
- "default: false\n"
- " --int64_1 \\(Test int64 flag\\) type: int64 "
- "default: 0\n"
- " --int_1 \\(Test int flag\\) type: int default: 0\n"
- " --string_1 \\(Test string flag\\) type: string "
- "default: \"\"\n"
- " --uint64_1 \\(Test uint64 flag\\) type: uint64 "
- "default: 0\n"
-);
+ ASSERT_EXIT(
+ chromeos::FlagHelper::Init(arraysize(argv), argv, "TestHelpMessage"),
+ ::testing::ExitedWithCode(EX_OK),
+ "TestHelpMessage\n\n"
+ " --bool_1 \\(Test bool flag\\) type: bool default: true\n"
+ " --double_1 \\(Test double flag\\) type: double default: 0\n"
+ " --help \\(Show this help message\\) type: bool default: false\n"
+ " --int64_1 \\(Test int64 flag\\) type: int64 default: 0\n"
+ " --int_1 \\(Test int flag\\) type: int default: 0\n"
+ " --string_1 \\(Test string flag\\) type: string default: \"\"\n"
+ " --uint64_1 \\(Test uint64 flag\\) type: uint64 default: 0\n");
stdout = orig;
}
@@ -238,7 +251,7 @@
// Test that passing in unknown command line flags causes the program
// to exit with EX_USAGE error code and corresponding error message.
TEST_F(FlagHelperTest, UnknownFlag) {
- const char* argv[] = {"test_program", "--flag=value" };
+ const char* argv[] = {"test_program", "--flag=value"};
CommandLine command_line(arraysize(argv), argv);
chromeos::FlagHelper::GetInstance()->set_command_line_for_testing(
@@ -259,7 +272,7 @@
TEST_F(FlagHelperTest, BoolParseError) {
DEFINE_bool(bool_1, 0, "Test bool flag");
- const char* argv[] = {"test_program", "--bool_1=value" };
+ const char* argv[] = {"test_program", "--bool_1=value"};
CommandLine command_line(arraysize(argv), argv);
chromeos::FlagHelper::GetInstance()->set_command_line_for_testing(
@@ -268,11 +281,10 @@
FILE* orig = stdout;
stdout = stderr;
- ASSERT_EXIT(chromeos::FlagHelper::Init(arraysize(argv),
- argv,
- "TestBoolParseError"),
- ::testing::ExitedWithCode(EX_DATAERR),
- "ERROR: illegal value 'value' specified for bool flag 'bool_1'");
+ ASSERT_EXIT(
+ chromeos::FlagHelper::Init(arraysize(argv), argv, "TestBoolParseError"),
+ ::testing::ExitedWithCode(EX_DATAERR),
+ "ERROR: illegal value 'value' specified for bool flag 'bool_1'");
stdout = orig;
}
@@ -282,7 +294,7 @@
TEST_F(FlagHelperTest, Int32ParseError) {
DEFINE_int32(int_1, 0, "Test int flag");
- const char* argv[] = {"test_program", "--int_1=value" };
+ const char* argv[] = {"test_program", "--int_1=value"};
CommandLine command_line(arraysize(argv), argv);
chromeos::FlagHelper::GetInstance()->set_command_line_for_testing(
@@ -314,12 +326,11 @@
FILE* orig = stdout;
stdout = stderr;
- ASSERT_EXIT(chromeos::FlagHelper::Init(arraysize(argv),
- argv,
- "TestInt64ParseError"),
- ::testing::ExitedWithCode(EX_DATAERR),
- "ERROR: illegal value 'value' specified for int64 flag "
- "'int64_1'");
+ ASSERT_EXIT(
+ chromeos::FlagHelper::Init(arraysize(argv), argv, "TestInt64ParseError"),
+ ::testing::ExitedWithCode(EX_DATAERR),
+ "ERROR: illegal value 'value' specified for int64 flag "
+ "'int64_1'");
stdout = orig;
}
@@ -329,7 +340,7 @@
TEST_F(FlagHelperTest, UInt64ParseError) {
DEFINE_uint64(uint64_1, 0, "Test uint64 flag");
- const char* argv[] = {"test_program", "--uint64_1=value" };
+ const char* argv[] = {"test_program", "--uint64_1=value"};
CommandLine command_line(arraysize(argv), argv);
chromeos::FlagHelper::GetInstance()->set_command_line_for_testing(
@@ -338,12 +349,11 @@
FILE* orig = stdout;
stdout = stderr;
- ASSERT_EXIT(chromeos::FlagHelper::Init(arraysize(argv),
- argv,
- "TestUInt64ParseError"),
- ::testing::ExitedWithCode(EX_DATAERR),
- "ERROR: illegal value 'value' specified for uint64 flag "
- "'uint64_1'");
+ ASSERT_EXIT(
+ chromeos::FlagHelper::Init(arraysize(argv), argv, "TestUInt64ParseError"),
+ ::testing::ExitedWithCode(EX_DATAERR),
+ "ERROR: illegal value 'value' specified for uint64 flag "
+ "'uint64_1'");
stdout = orig;
}
diff --git a/chromeos/http/curl_api.h b/chromeos/http/curl_api.h
index eb47a96..0f78f22 100644
--- a/chromeos/http/curl_api.h
+++ b/chromeos/http/curl_api.h
@@ -47,8 +47,8 @@
inline CURLcode EasySetOptCallback(CURL* curl,
CURLoption option,
R(*callback)(Args...)) {
- return EasySetOptCallback(curl, option,
- reinterpret_cast<intptr_t>(callback));
+ return EasySetOptCallback(
+ curl, option, reinterpret_cast<intptr_t>(callback));
}
// Wrapper around curl_easy_perform().
@@ -100,9 +100,7 @@
CURLcode EasyPerform(CURL* curl) override;
// Wrappers around curl_easy_getinfo().
- CURLcode EasyGetInfoInt(CURL* curl,
- CURLINFO info,
- int* value) const override;
+ CURLcode EasyGetInfoInt(CURL* curl, CURLINFO info, int* value) const override;
CURLcode EasyGetInfoDbl(CURL* curl,
CURLINFO info,
double* value) const override;
diff --git a/chromeos/http/http_connection.h b/chromeos/http/http_connection.h
index fa1e7f1..750e987 100644
--- a/chromeos/http/http_connection.h
+++ b/chromeos/http/http_connection.h
@@ -52,9 +52,8 @@
virtual bool FinishRequest(chromeos::ErrorPtr* error) = 0;
// Send the request asynchronously and invoke the callback with the response
// received.
- virtual void FinishRequestAsync(
- const SuccessCallback& success_callback,
- const ErrorCallback& error_callback) = 0;
+ virtual void FinishRequestAsync(const SuccessCallback& success_callback,
+ const ErrorCallback& error_callback) = 0;
// Returns the HTTP status code (e.g. 200 for success).
virtual int GetResponseStatusCode() const = 0;
diff --git a/chromeos/http/http_connection_curl.cc b/chromeos/http/http_connection_curl.cc
index 62c9c97..766e792 100644
--- a/chromeos/http/http_connection_curl.cc
+++ b/chromeos/http/http_connection_curl.cc
@@ -13,34 +13,37 @@
namespace http {
namespace curl {
-static int curl_trace(CURL *handle, curl_infotype type,
- char *data, size_t size, void *userp) {
+static int curl_trace(CURL* handle,
+ curl_infotype type,
+ char* data,
+ size_t size,
+ void* userp) {
std::string msg(data, size);
switch (type) {
- case CURLINFO_TEXT:
- VLOG(3) << "== Info: " << msg;
- break;
- case CURLINFO_HEADER_OUT:
- VLOG(3) << "=> Send headers:\n" << msg;
- break;
- case CURLINFO_DATA_OUT:
- VLOG(3) << "=> Send data:\n" << msg;
- break;
- case CURLINFO_SSL_DATA_OUT:
- VLOG(3) << "=> Send SSL data" << msg;
- break;
- case CURLINFO_HEADER_IN:
- VLOG(3) << "<= Recv header: " << msg;
- break;
- case CURLINFO_DATA_IN:
- VLOG(3) << "<= Recv data:\n" << msg;
- break;
- case CURLINFO_SSL_DATA_IN:
- VLOG(3) << "<= Recv SSL data" << msg;
- break;
- default:
- break;
+ case CURLINFO_TEXT:
+ VLOG(3) << "== Info: " << msg;
+ break;
+ case CURLINFO_HEADER_OUT:
+ VLOG(3) << "=> Send headers:\n" << msg;
+ break;
+ case CURLINFO_DATA_OUT:
+ VLOG(3) << "=> Send data:\n" << msg;
+ break;
+ case CURLINFO_SSL_DATA_OUT:
+ VLOG(3) << "=> Send SSL data" << msg;
+ break;
+ case CURLINFO_HEADER_IN:
+ VLOG(3) << "<= Recv header: " << msg;
+ break;
+ case CURLINFO_DATA_IN:
+ VLOG(3) << "<= Recv data:\n" << msg;
+ break;
+ case CURLINFO_SSL_DATA_IN:
+ VLOG(3) << "<= Recv SSL data" << msg;
+ break;
+ default:
+ break;
}
return 0;
}
@@ -78,8 +81,8 @@
void Connection::PrepareRequest() {
if (VLOG_IS_ON(3)) {
- curl_interface_->EasySetOptCallback(curl_handle_, CURLOPT_DEBUGFUNCTION,
- &curl_trace);
+ curl_interface_->EasySetOptCallback(
+ curl_handle_, CURLOPT_DEBUGFUNCTION, &curl_trace);
curl_interface_->EasySetOptInt(curl_handle_, CURLOPT_VERBOSE, 1);
}
@@ -87,15 +90,15 @@
uint64_t data_size =
request_data_reader_ ? request_data_reader_->GetDataSize() : 0;
if (method_ == request_type::kPut) {
- curl_interface_->EasySetOptOffT(curl_handle_, CURLOPT_INFILESIZE_LARGE,
- data_size);
+ curl_interface_->EasySetOptOffT(
+ curl_handle_, CURLOPT_INFILESIZE_LARGE, data_size);
} else {
- curl_interface_->EasySetOptOffT(curl_handle_, CURLOPT_POSTFIELDSIZE_LARGE,
- data_size);
+ curl_interface_->EasySetOptOffT(
+ curl_handle_, CURLOPT_POSTFIELDSIZE_LARGE, data_size);
}
if (request_data_reader_) {
- curl_interface_->EasySetOptCallback(curl_handle_, CURLOPT_READFUNCTION,
- &Connection::read_callback);
+ curl_interface_->EasySetOptCallback(
+ curl_handle_, CURLOPT_READFUNCTION, &Connection::read_callback);
curl_interface_->EasySetOptPtr(curl_handle_, CURLOPT_READDATA, this);
}
@@ -107,22 +110,22 @@
VLOG(2) << "Request header: " << header;
header_list_ = curl_slist_append(header_list_, header.c_str());
}
- curl_interface_->EasySetOptPtr(curl_handle_, CURLOPT_HTTPHEADER,
- header_list_);
+ curl_interface_->EasySetOptPtr(
+ curl_handle_, CURLOPT_HTTPHEADER, header_list_);
}
headers_.clear();
// Set up HTTP response data.
if (method_ != request_type::kHead) {
- curl_interface_->EasySetOptCallback(curl_handle_, CURLOPT_WRITEFUNCTION,
- &Connection::write_callback);
+ curl_interface_->EasySetOptCallback(
+ curl_handle_, CURLOPT_WRITEFUNCTION, &Connection::write_callback);
curl_interface_->EasySetOptPtr(curl_handle_, CURLOPT_WRITEDATA, this);
}
// HTTP response headers
- curl_interface_->EasySetOptCallback(curl_handle_, CURLOPT_HEADERFUNCTION,
- &Connection::header_callback);
+ curl_interface_->EasySetOptCallback(
+ curl_handle_, CURLOPT_HEADERFUNCTION, &Connection::header_callback);
curl_interface_->EasySetOptPtr(curl_handle_, CURLOPT_HEADERDATA, this);
}
@@ -133,25 +136,24 @@
Transport::AddCurlError(error, FROM_HERE, ret, curl_interface_.get());
} else {
LOG(INFO) << "Response: " << GetResponseStatusCode() << " ("
- << GetResponseStatusText() << ")";
+ << GetResponseStatusText() << ")";
VLOG(2) << "Response data (" << response_data_.size() << "): "
- << std::string(reinterpret_cast<const char*>(response_data_.data()),
- response_data_.size());
+ << std::string(reinterpret_cast<const char*>(response_data_.data()),
+ response_data_.size());
}
return (ret == CURLE_OK);
}
-void Connection::FinishRequestAsync(
- const SuccessCallback& success_callback,
- const ErrorCallback& error_callback) {
+void Connection::FinishRequestAsync(const SuccessCallback& success_callback,
+ const ErrorCallback& error_callback) {
PrepareRequest();
transport_->StartAsyncTransfer(this, success_callback, error_callback);
}
int Connection::GetResponseStatusCode() const {
int status_code = 0;
- curl_interface_->EasyGetInfoInt(curl_handle_, CURLINFO_RESPONSE_CODE,
- &status_code);
+ curl_interface_->EasyGetInfoInt(
+ curl_handle_, CURLINFO_RESPONSE_CODE, &status_code);
return status_code;
}
@@ -187,16 +189,20 @@
return true;
}
-size_t Connection::write_callback(char* ptr, size_t size,
- size_t num, void* data) {
+size_t Connection::write_callback(char* ptr,
+ size_t size,
+ size_t num,
+ void* data) {
Connection* me = reinterpret_cast<Connection*>(data);
size_t data_len = size * num;
me->response_data_.insert(me->response_data_.end(), ptr, ptr + data_len);
return data_len;
}
-size_t Connection::read_callback(char* ptr, size_t size,
- size_t num, void* data) {
+size_t Connection::read_callback(char* ptr,
+ size_t size,
+ size_t num,
+ void* data) {
Connection* me = reinterpret_cast<Connection*>(data);
size_t data_len = size * num;
@@ -207,8 +213,10 @@
return success ? read_size : CURL_READFUNC_ABORT;
}
-size_t Connection::header_callback(char* ptr, size_t size,
- size_t num, void* data) {
+size_t Connection::header_callback(char* ptr,
+ size_t size,
+ size_t num,
+ void* data) {
using chromeos::string_utils::SplitAtFirst;
Connection* me = reinterpret_cast<Connection*>(data);
size_t hdr_len = size * num;
diff --git a/chromeos/http/http_connection_curl.h b/chromeos/http/http_connection_curl.h
index d926237..8ac11d9 100644
--- a/chromeos/http/http_connection_curl.h
+++ b/chromeos/http/http_connection_curl.h
@@ -43,19 +43,27 @@
std::string GetProtocolVersion() const override;
std::string GetResponseHeader(const std::string& header_name) const override;
uint64_t GetResponseDataSize() const override;
- bool ReadResponseData(void* data, size_t buffer_size,
- size_t* size_read, chromeos::ErrorPtr* error) override;
+ bool ReadResponseData(void* data,
+ size_t buffer_size,
+ size_t* size_read,
+ chromeos::ErrorPtr* error) override;
protected:
// Write data callback. Used by CURL when receiving response data.
- CHROMEOS_PRIVATE static size_t write_callback(char* ptr, size_t size,
- size_t num, void* data);
+ CHROMEOS_PRIVATE static size_t write_callback(char* ptr,
+ size_t size,
+ size_t num,
+ void* data);
// Read data callback. Used by CURL when sending request body data.
- CHROMEOS_PRIVATE static size_t read_callback(char* ptr, size_t size,
- size_t num, void* data);
+ CHROMEOS_PRIVATE static size_t read_callback(char* ptr,
+ size_t size,
+ size_t num,
+ void* data);
// Write header data callback. Used by CURL when receiving response headers.
- CHROMEOS_PRIVATE static size_t header_callback(char* ptr, size_t size,
- size_t num, void* data);
+ CHROMEOS_PRIVATE static size_t header_callback(char* ptr,
+ size_t size,
+ size_t num,
+ void* data);
// Helper method to set up the |curl_handle_| with all the parameters
// pertaining to the current connection.
diff --git a/chromeos/http/http_connection_curl_unittest.cc b/chromeos/http/http_connection_curl_unittest.cc
index 0a46450..0cbda1a 100644
--- a/chromeos/http/http_connection_curl_unittest.cc
+++ b/chromeos/http/http_connection_curl_unittest.cc
@@ -83,8 +83,8 @@
std::vector<std::string> header_lines;
header_lines.push_back(status_line + "\r\n");
for (const auto& pair : response_headers) {
- header_lines.push_back(
- string_utils::Join(": ", pair.first, pair.second) + "\r\n");
+ header_lines.push_back(string_utils::Join(": ", pair.first, pair.second) +
+ "\r\n");
}
for (const std::string& line : header_lines) {
@@ -103,8 +103,8 @@
size_t pos = 0;
size_t size_remaining = str.size();
while (size_remaining) {
- size_t size_written = callback(const_cast<char*>(str.data() + pos),
- size_remaining, 1, connection);
+ size_t size_written = callback(
+ const_cast<char*>(str.data() + pos), size_remaining, 1, connection);
if (size_written == CURL_WRITEFUNC_PAUSE)
return CURLE_WRITE_ERROR; // Shouldn't happen.
CHECK(size_written <= size_remaining) << "Unexpected size returned";
@@ -150,8 +150,8 @@
void SetUp() override {
curl_api_ = std::make_shared<MockCurlInterface>();
transport_ = std::make_shared<MockTransport>();
- connection_ = std::make_shared<Connection>(handle_, request_type::kPost,
- curl_api_, transport_);
+ connection_ = std::make_shared<Connection>(
+ handle_, request_type::kPost, curl_api_, transport_);
performer_.connection = connection_.get();
}
@@ -184,8 +184,9 @@
.WillOnce(Return(CURLE_OK));
}
- EXPECT_CALL(*curl_api_, EasySetOptOffT(handle_, CURLOPT_POSTFIELDSIZE_LARGE,
- request_data.size()))
+ EXPECT_CALL(
+ *curl_api_,
+ EasySetOptOffT(handle_, CURLOPT_POSTFIELDSIZE_LARGE, request_data.size()))
.WillOnce(Return(CURLE_OK));
EXPECT_CALL(*curl_api_, EasySetOptCallback(handle_, CURLOPT_READFUNCTION, _))
@@ -218,10 +219,10 @@
std::string request_data{"Foo Bar Baz"};
std::unique_ptr<MemoryDataReader> reader{new MemoryDataReader{request_data}};
HeaderList headers{
- {request_header::kAccept, "*/*"},
- {request_header::kContentType, mime::text::kPlain},
- {request_header::kContentLength, std::to_string(request_data.size())},
- {"X-Foo", "bar"},
+ {request_header::kAccept, "*/*"},
+ {request_header::kContentType, mime::text::kPlain},
+ {request_header::kContentLength, std::to_string(request_data.size())},
+ {"X-Foo", "bar"},
};
EXPECT_TRUE(connection_->SetRequestData(std::move(reader), nullptr));
EXPECT_TRUE(connection_->SendHeaders(headers, nullptr));
@@ -235,14 +236,15 @@
.WillOnce(Return(CURLE_OK));
}
- EXPECT_CALL(*curl_api_, EasySetOptOffT(handle_, CURLOPT_POSTFIELDSIZE_LARGE,
- request_data.size()))
+ EXPECT_CALL(
+ *curl_api_,
+ EasySetOptOffT(handle_, CURLOPT_POSTFIELDSIZE_LARGE, request_data.size()))
.WillOnce(Return(CURLE_OK));
EXPECT_CALL(*curl_api_, EasySetOptCallback(handle_, CURLOPT_READFUNCTION, _))
- .WillOnce(DoAll(
- SaveCallback<2>(&performer_, &CurlPerformer::read_callback),
- Return(CURLE_OK)));
+ .WillOnce(
+ DoAll(SaveCallback<2>(&performer_, &CurlPerformer::read_callback),
+ Return(CURLE_OK)));
EXPECT_CALL(*curl_api_, EasySetOptPtr(handle_, CURLOPT_READDATA, _))
.WillOnce(Return(CURLE_OK));
@@ -251,17 +253,17 @@
.WillOnce(Return(CURLE_OK));
EXPECT_CALL(*curl_api_, EasySetOptCallback(handle_, CURLOPT_WRITEFUNCTION, _))
- .WillOnce(DoAll(
- SaveCallback<2>(&performer_, &CurlPerformer::write_callback),
- Return(CURLE_OK)));
+ .WillOnce(
+ DoAll(SaveCallback<2>(&performer_, &CurlPerformer::write_callback),
+ Return(CURLE_OK)));
EXPECT_CALL(*curl_api_, EasySetOptPtr(handle_, CURLOPT_WRITEDATA, _))
.WillOnce(Return(CURLE_OK));
EXPECT_CALL(*curl_api_,
EasySetOptCallback(handle_, CURLOPT_HEADERFUNCTION, _))
- .WillOnce(DoAll(
- SaveCallback<2>(&performer_, &CurlPerformer::header_callback),
- Return(CURLE_OK)));
+ .WillOnce(
+ DoAll(SaveCallback<2>(&performer_, &CurlPerformer::header_callback),
+ Return(CURLE_OK)));
EXPECT_CALL(*curl_api_, EasySetOptPtr(handle_, CURLOPT_HEADERDATA, _))
.WillOnce(Return(CURLE_OK));
@@ -274,9 +276,9 @@
// Set up the CurlPerformer with the response data expected to be received.
std::string response_data{"<html><body>OK</body></html>"};
HeaderList response_headers{
- {response_header::kContentLength, std::to_string(response_data.size())},
- {response_header::kContentType, mime::text::kHtml},
- {"X-Foo", "baz"},
+ {response_header::kContentLength, std::to_string(response_data.size())},
+ {response_header::kContentType, mime::text::kHtml},
+ {"X-Foo", "baz"},
};
performer_.status_line = "HTTP/1.1 200 OK";
performer_.response_body = response_data;
@@ -302,8 +304,8 @@
EXPECT_EQ(response_data.size(), connection_->GetResponseDataSize());
char buffer[100];
size_t size_read = 0;
- EXPECT_TRUE(connection_->ReadResponseData(buffer, sizeof(buffer), &size_read,
- nullptr));
+ EXPECT_TRUE(connection_->ReadResponseData(
+ buffer, sizeof(buffer), &size_read, nullptr));
EXPECT_EQ(response_data, (std::string{buffer, size_read}));
}
diff --git a/chromeos/http/http_connection_fake.cc b/chromeos/http/http_connection_fake.cc
index d10d242..4ab3d83 100644
--- a/chromeos/http/http_connection_fake.cc
+++ b/chromeos/http/http_connection_fake.cc
@@ -14,9 +14,10 @@
namespace http {
namespace fake {
-Connection::Connection(const std::string& url, const std::string& method,
- const std::shared_ptr<http::Transport>& transport) :
- http::Connection(transport), request_(url, method) {
+Connection::Connection(const std::string& url,
+ const std::string& method,
+ const std::shared_ptr<http::Transport>& transport)
+ : http::Connection(transport), request_(url, method) {
VLOG(1) << "fake::Connection created: " << method;
}
@@ -39,8 +40,8 @@
bool Connection::FinishRequest(chromeos::ErrorPtr* error) {
using chromeos::string_utils::ToString;
- request_.AddHeaders({{request_header::kContentLength,
- ToString(request_.GetData().size())}});
+ request_.AddHeaders(
+ {{request_header::kContentLength, ToString(request_.GetData().size())}});
fake::Transport* transport = static_cast<fake::Transport*>(transport_.get());
CHECK(transport) << "Expecting a fake transport";
auto handler = transport->GetHandler(request_.GetURL(), request_.GetMethod());
@@ -56,14 +57,13 @@
return true;
}
-void Connection::FinishRequestAsync(
- const SuccessCallback& success_callback,
- const ErrorCallback& error_callback) {
- transport_->RunCallbackAsync(
- FROM_HERE, base::Bind(&Connection::FinishRequestAsyncHelper,
- base::Unretained(this),
- success_callback,
- error_callback));
+void Connection::FinishRequestAsync(const SuccessCallback& success_callback,
+ const ErrorCallback& error_callback) {
+ transport_->RunCallbackAsync(FROM_HERE,
+ base::Bind(&Connection::FinishRequestAsyncHelper,
+ base::Unretained(this),
+ success_callback,
+ error_callback));
}
void Connection::FinishRequestAsyncHelper(
@@ -97,8 +97,9 @@
uint64_t Connection::GetResponseDataSize() const {
// HEAD requests must not return body.
- return (request_.GetMethod() != request_type::kHead) ?
- response_.GetData().size() : 0;
+ return (request_.GetMethod() != request_type::kHead)
+ ? response_.GetData().size()
+ : 0;
}
bool Connection::ReadResponseData(void* data,
diff --git a/chromeos/http/http_connection_fake.h b/chromeos/http/http_connection_fake.h
index b81d473..0598859 100644
--- a/chromeos/http/http_connection_fake.h
+++ b/chromeos/http/http_connection_fake.h
@@ -20,7 +20,8 @@
// This is a fake implementation of http::Connection for unit testing.
class Connection : public http::Connection {
public:
- Connection(const std::string& url, const std::string& method,
+ Connection(const std::string& url,
+ const std::string& method,
const std::shared_ptr<http::Transport>& transport);
virtual ~Connection();
@@ -39,8 +40,10 @@
std::string GetProtocolVersion() const override;
std::string GetResponseHeader(const std::string& header_name) const override;
uint64_t GetResponseDataSize() const override;
- bool ReadResponseData(void* data, size_t buffer_size,
- size_t* size_read, chromeos::ErrorPtr* error) override;
+ bool ReadResponseData(void* data,
+ size_t buffer_size,
+ size_t* size_read,
+ chromeos::ErrorPtr* error) override;
private:
// A helper method for FinishRequestAsync() implementation.
diff --git a/chromeos/http/http_form_data.cc b/chromeos/http/http_form_data.cc
index b1e0d16..540d279 100644
--- a/chromeos/http/http_form_data.cc
+++ b/chromeos/http/http_form_data.cc
@@ -33,7 +33,8 @@
: name_{name},
content_disposition_{content_disposition},
content_type_{content_type},
- transfer_encoding_{transfer_encoding} {}
+ transfer_encoding_{transfer_encoding} {
+}
std::string FormField::GetContentDisposition() const {
std::string disposition = content_disposition_;
@@ -48,7 +49,7 @@
std::string FormField::GetContentHeader() const {
HeaderList headers{
- {form_header::kContentDisposition, GetContentDisposition()}
+ {form_header::kContentDisposition, GetContentDisposition()}
};
if (!content_type_.empty())
@@ -61,8 +62,8 @@
std::string result;
for (const auto& pair : headers) {
- base::StringAppendF(&result, "%s: %s\r\n",
- pair.first.c_str(), pair.second.c_str());
+ base::StringAppendF(
+ &result, "%s: %s\r\n", pair.first.c_str(), pair.second.c_str());
}
result += "\r\n";
return result;
@@ -72,9 +73,12 @@
const std::string& data,
const std::string& content_type,
const std::string& transfer_encoding)
- : FormField{name, content_disposition::kFormData, content_type,
+ : FormField{name,
+ content_disposition::kFormData,
+ content_type,
transfer_encoding},
- data_{data} {}
+ data_{data} {
+}
uint64_t TextFormField::GetDataSize() const {
return data_.GetDataSize();
@@ -93,10 +97,10 @@
const std::string& content_disposition,
const std::string& content_type,
const std::string& transfer_encoding)
- : FormField{name, content_disposition, content_type, transfer_encoding},
- file_{file.Pass()},
- file_name_{file_name} {}
-
+ : FormField{name, content_disposition, content_type, transfer_encoding},
+ file_{file.Pass()},
+ file_name_{file_name} {
+}
uint64_t FileFormField::GetDataSize() const {
// Unfortunately base::File::GetLength() is not a const method of the class,
@@ -139,7 +143,8 @@
MultiPartFormField::MultiPartFormField(const std::string& name,
const std::string& content_type,
const std::string& boundary)
- : FormField{name, content_disposition::kFormData,
+ : FormField{name,
+ content_disposition::kFormData,
content_type.empty() ? mime::multipart::kMixed : content_type,
{}},
boundary_{boundary} {
@@ -162,8 +167,8 @@
}
std::string MultiPartFormField::GetContentType() const {
- return base::StringPrintf("%s; boundary=\"%s\"",
- content_type_.c_str(), boundary_.c_str());
+ return base::StringPrintf(
+ "%s; boundary=\"%s\"", content_type_.c_str(), boundary_.c_str());
}
bool MultiPartFormField::ReadData(void* buffer,
@@ -187,8 +192,8 @@
std::string boundary;
if (read_part_index_ > 0)
boundary = "\r\n";
- boundary += GetBoundaryStart() +
- parts_[read_part_index_]->GetContentHeader();
+ boundary +=
+ GetBoundaryStart() + parts_[read_part_index_]->GetContentHeader();
boundary_reader_.SetData(boundary);
} else if (read_stage_ == ReadStage::kBoundarySetup &&
read_part_index_ >= parts_.size()) {
@@ -207,8 +212,8 @@
read_stage_ = ReadStage::kPart;
} else if (read_stage_ == ReadStage::kPart) {
// Reading the actual part data.
- if (!parts_[read_part_index_]->ReadData(buffer, size_to_read,
- size_read, error)) {
+ if (!parts_[read_part_index_]->ReadData(
+ buffer, size_to_read, size_read, error)) {
return false;
}
if (*size_read > 0)
@@ -240,10 +245,12 @@
return false;
}
std::string file_name = file_path.BaseName().value();
- std::unique_ptr<FormField> file_field{
- new FileFormField{name, file.Pass(), file_name, content_disposition,
- content_type, "binary" }
- };
+ std::unique_ptr<FormField> file_field{new FileFormField{name,
+ file.Pass(),
+ file_name,
+ content_disposition,
+ content_type,
+ "binary"}};
AddCustomField(std::move(file_field));
return true;
}
@@ -256,17 +263,18 @@
return base::StringPrintf("--%s--", boundary_.c_str());
}
-FormData::FormData() : FormData{std::string{}} {}
+FormData::FormData() : FormData{std::string{}} {
+}
FormData::FormData(const std::string& boundary)
- : form_data_{"", mime::multipart::kFormData, boundary} {}
+ : form_data_{"", mime::multipart::kFormData, boundary} {
+}
void FormData::AddCustomField(std::unique_ptr<FormField> field) {
form_data_.AddCustomField(std::move(field));
}
-void FormData::AddTextField(const std::string& name,
- const std::string& data) {
+void FormData::AddTextField(const std::string& name, const std::string& data) {
form_data_.AddTextField(name, data);
}
@@ -274,9 +282,8 @@
const base::FilePath& file_path,
const std::string& content_type,
chromeos::ErrorPtr* error) {
- return form_data_.AddFileField(name, file_path,
- content_disposition::kFormData,
- content_type, error);
+ return form_data_.AddFileField(
+ name, file_path, content_disposition::kFormData, content_type, error);
}
std::string FormData::GetContentType() const {
diff --git a/chromeos/http/http_form_data.h b/chromeos/http/http_form_data.h
index ac7253c..919f02c 100644
--- a/chromeos/http/http_form_data.h
+++ b/chromeos/http/http_form_data.h
@@ -179,8 +179,7 @@
void AddCustomField(std::unique_ptr<FormField> field);
// Adds a simple text form field.
- void AddTextField(const std::string& name,
- const std::string& data);
+ void AddTextField(const std::string& name, const std::string& data);
// Adds a file upload form field using a file path.
bool AddFileField(const std::string& name,
@@ -232,8 +231,7 @@
void AddCustomField(std::unique_ptr<FormField> field);
// Adds a simple text form field.
- void AddTextField(const std::string& name,
- const std::string& data);
+ void AddTextField(const std::string& name, const std::string& data);
// Adds a file upload form field using a file path.
bool AddFileField(const std::string& name,
diff --git a/chromeos/http/http_form_data_unittest.cc b/chromeos/http/http_form_data_unittest.cc
index 27768ef..15b02bd 100644
--- a/chromeos/http/http_form_data_unittest.cc
+++ b/chromeos/http/http_form_data_unittest.cc
@@ -36,14 +36,17 @@
std::string file_content{"text line1\ntext line2\n"};
base::FilePath file_name = dir.path().Append("sample.txt");
ASSERT_EQ(file_content.size(),
- static_cast<size_t>(base::WriteFile(file_name, file_content.data(),
- file_content.size())));
+ static_cast<size_t>(base::WriteFile(
+ file_name, file_content.data(), file_content.size())));
base::File file{file_name, base::File::FLAG_READ | base::File::FLAG_OPEN};
ASSERT_TRUE(file.IsValid());
- FileFormField form_field{"test_file", file.Pass(), "sample.txt",
+ FileFormField form_field{"test_file",
+ file.Pass(),
+ "sample.txt",
content_disposition::kFormData,
- mime::text::kPlain, ""};
+ mime::text::kPlain,
+ ""};
const char expected_header[] =
"Content-Disposition: form-data; name=\"test_file\";"
" filename=\"sample.txt\"\r\n"
@@ -64,20 +67,23 @@
std::string file1{"text line1\ntext line2\n"};
base::FilePath filename1 = dir.path().Append("sample.txt");
ASSERT_EQ(file1.size(),
- static_cast<size_t>(base::WriteFile(filename1, file1.data(),
- file1.size())));
+ static_cast<size_t>(
+ base::WriteFile(filename1, file1.data(), file1.size())));
std::string file2{"\x01\x02\x03\x04\x05"};
base::FilePath filename2 = dir.path().Append("test.bin");
ASSERT_EQ(file2.size(),
- static_cast<size_t>(base::WriteFile(filename2, file2.data(),
- file2.size())));
+ static_cast<size_t>(
+ base::WriteFile(filename2, file2.data(), file2.size())));
MultiPartFormField form_field{"foo", mime::multipart::kFormData, "Delimiter"};
form_field.AddTextField("name", "John Doe");
- EXPECT_TRUE(form_field.AddFileField("file1", filename1,
+ EXPECT_TRUE(form_field.AddFileField("file1",
+ filename1,
content_disposition::kFormData,
- mime::text::kPlain, nullptr));
- EXPECT_TRUE(form_field.AddFileField("file2", filename2,
+ mime::text::kPlain,
+ nullptr));
+ EXPECT_TRUE(form_field.AddFileField("file2",
+ filename2,
content_disposition::kFormData,
mime::application::kOctet_stream,
nullptr));
@@ -146,22 +152,22 @@
std::string file1{"text line1\ntext line2\n"};
base::FilePath filename1 = dir.path().Append("sample.txt");
ASSERT_EQ(file1.size(),
- static_cast<size_t>(base::WriteFile(filename1, file1.data(),
- file1.size())));
+ static_cast<size_t>(
+ base::WriteFile(filename1, file1.data(), file1.size())));
std::string file2{"\x01\x02\x03\x04\x05"};
base::FilePath filename2 = dir.path().Append("test.bin");
ASSERT_EQ(file2.size(),
- static_cast<size_t>(base::WriteFile(filename2, file2.data(),
- file2.size())));
+ static_cast<size_t>(
+ base::WriteFile(filename2, file2.data(), file2.size())));
FormData form_data{"boundary1"};
form_data.AddTextField("name", "John Doe");
std::unique_ptr<MultiPartFormField> files{
new MultiPartFormField{"files", "", "boundary2"}};
- EXPECT_TRUE(files->AddFileField("", filename1,
- content_disposition::kFile,
- mime::text::kPlain, nullptr));
- EXPECT_TRUE(files->AddFileField("", filename2,
+ EXPECT_TRUE(files->AddFileField(
+ "", filename1, content_disposition::kFile, mime::text::kPlain, nullptr));
+ EXPECT_TRUE(files->AddFileField("",
+ filename2,
content_disposition::kFile,
mime::application::kOctet_stream,
nullptr));
diff --git a/chromeos/http/http_request.cc b/chromeos/http/http_request.cc
index 40e1a14..bcc442e 100644
--- a/chromeos/http/http_request.cc
+++ b/chromeos/http/http_request.cc
@@ -103,9 +103,10 @@
// ***********************************************************
// ********************** Request Class **********************
// ***********************************************************
-Request::Request(const std::string& url, const std::string& method,
- std::shared_ptr<Transport> transport) :
- transport_(transport), request_url_(url), method_(method) {
+Request::Request(const std::string& url,
+ const std::string& method,
+ std::shared_ptr<Transport> transport)
+ : transport_(transport), request_url_(url), method_(method) {
VLOG(1) << "http::Request created";
if (!transport_)
transport_ = http::Transport::CreateDefault();
@@ -180,7 +181,7 @@
if (!SendRequestIfNeeded(error))
return false;
std::unique_ptr<DataReaderInterface> data_reader{
- new MemoryDataReader{data, size}
+ new MemoryDataReader{data, size}
};
return connection_->SetRequestData(std::move(data_reader), error);
}
@@ -246,23 +247,25 @@
}
}
if (!ranges.empty())
- headers.emplace_back(request_header::kRange,
- "bytes=" +
- chromeos::string_utils::Join(',', ranges));
+ headers.emplace_back(
+ request_header::kRange,
+ "bytes=" + chromeos::string_utils::Join(',', ranges));
headers.emplace_back(request_header::kAccept, GetAccept());
if (method_ != request_type::kGet && method_ != request_type::kHead) {
if (!content_type_.empty())
headers.emplace_back(request_header::kContentType, content_type_);
}
- connection_ = transport_->CreateConnection(request_url_, method_, headers,
- user_agent_, referer_, error);
+ connection_ = transport_->CreateConnection(
+ request_url_, method_, headers, user_agent_, referer_, error);
}
if (connection_)
return true;
} else {
- chromeos::Error::AddTo(error, FROM_HERE, http::kErrorDomain,
+ chromeos::Error::AddTo(error,
+ FROM_HERE,
+ http::kErrorDomain,
"response_already_received",
"HTTP response already received");
}
@@ -282,8 +285,9 @@
response_data_.reserve(size);
uint8_t buffer[1024];
size_t read = 0;
- while (connection_->ReadResponseData(buffer, sizeof(buffer),
- &read, nullptr) && read > 0) {
+ while (
+ connection_->ReadResponseData(buffer, sizeof(buffer), &read, nullptr) &&
+ read > 0) {
response_data_.insert(response_data_.end(), buffer, buffer + read);
}
}
diff --git a/chromeos/http/http_request_unittest.cc b/chromeos/http/http_request_unittest.cc
index 84e3c91..0f5cbd8 100644
--- a/chromeos/http/http_request_unittest.cc
+++ b/chromeos/http/http_request_unittest.cc
@@ -109,8 +109,8 @@
request.SetAccept("text/*, text/html, text/html;level=1, */*");
request.AddHeader(request_header::kAcceptEncoding, "compress, gzip");
request.AddHeaders({
- {request_header::kAcceptLanguage, "da, en-gb;q=0.8, en;q=0.7"},
- {request_header::kConnection, "close"},
+ {request_header::kAcceptLanguage, "da, en-gb;q=0.8, en;q=0.7"},
+ {request_header::kConnection, "close"},
});
request.AddRange(-10);
request.AddRange(100, 200);
@@ -136,13 +136,11 @@
EXPECT_CALL(*connection_, MockSetRequestData(ContainsStringData(req_body), _))
.WillOnce(Return(true));
- EXPECT_TRUE(request.AddRequestBody(req_body.data(), req_body.size(),
- nullptr));
+ EXPECT_TRUE(
+ request.AddRequestBody(req_body.data(), req_body.size(), nullptr));
- EXPECT_CALL(*connection_, FinishRequest(_))
- .WillOnce(Return(true));
- EXPECT_CALL(*connection_, GetResponseDataSize())
- .WillOnce(Return(0));
+ EXPECT_CALL(*connection_, FinishRequest(_)).WillOnce(Return(true));
+ EXPECT_CALL(*connection_, GetResponseDataSize()).WillOnce(Return(0));
EXPECT_CALL(*connection_, ReadResponseData(_, _, _, _))
.WillOnce(DoAll(SetArgPointee<2>(0), Return(true)));
auto resp = request.GetResponseAndBlock(nullptr);
@@ -187,8 +185,9 @@
success_callback.Run(resp.Pass());
};
- EXPECT_CALL(*transport_, CreateConnection("http://foo.bar",
- request_type::kGet, _, "", "", _))
+ EXPECT_CALL(
+ *transport_,
+ CreateConnection("http://foo.bar", request_type::kGet, _, "", "", _))
.WillOnce(Return(connection_));
EXPECT_CALL(*connection_, FinishRequestAsync(_, _))
diff --git a/chromeos/http/http_transport.h b/chromeos/http/http_transport.h
index 080db33..dad54a3 100644
--- a/chromeos/http/http_transport.h
+++ b/chromeos/http/http_transport.h
@@ -63,10 +63,9 @@
// Initiates an asynchronous transfer on the given |connection|.
// The actual implementation of an async I/O is transport-specific.
- virtual void StartAsyncTransfer(
- Connection* connection,
- const SuccessCallback& success_callback,
- const ErrorCallback& error_callback) = 0;
+ virtual void StartAsyncTransfer(Connection* connection,
+ const SuccessCallback& success_callback,
+ const ErrorCallback& error_callback) = 0;
// Creates a default http::Transport (currently, using http::curl::Transport).
static std::shared_ptr<Transport> CreateDefault();
diff --git a/chromeos/http/http_transport_curl.cc b/chromeos/http/http_transport_curl.cc
index 43f0429..e4d4713 100644
--- a/chromeos/http/http_transport_curl.cc
+++ b/chromeos/http/http_transport_curl.cc
@@ -23,8 +23,7 @@
Transport::Transport(const std::shared_ptr<CurlInterface>& curl_interface,
scoped_refptr<base::TaskRunner> task_runner)
- : curl_interface_{curl_interface},
- task_runner_{task_runner} {
+ : curl_interface_{curl_interface}, task_runner_{task_runner} {
VLOG(1) << "curl::Transport created";
}
@@ -51,8 +50,11 @@
CURL* curl_handle = curl_interface_->EasyInit();
if (!curl_handle) {
LOG(ERROR) << "Failed to initialize CURL";
- chromeos::Error::AddTo(error, FROM_HERE, http::kErrorDomain,
- "curl_init_failed", "Failed to initialize CURL");
+ chromeos::Error::AddTo(error,
+ FROM_HERE,
+ http::kErrorDomain,
+ "curl_init_failed",
+ "Failed to initialize CURL");
return connection;
}
@@ -60,12 +62,12 @@
CURLcode code = curl_interface_->EasySetOptStr(curl_handle, CURLOPT_URL, url);
if (code == CURLE_OK && !user_agent.empty()) {
- code = curl_interface_->EasySetOptStr(curl_handle, CURLOPT_USERAGENT,
- user_agent);
+ code = curl_interface_->EasySetOptStr(
+ curl_handle, CURLOPT_USERAGENT, user_agent);
}
if (code == CURLE_OK && !referer.empty()) {
- code = curl_interface_->EasySetOptStr(curl_handle, CURLOPT_REFERER,
- referer);
+ code =
+ curl_interface_->EasySetOptStr(curl_handle, CURLOPT_REFERER, referer);
}
if (code == CURLE_OK && !proxy_.empty()) {
code = curl_interface_->EasySetOptStr(curl_handle, CURLOPT_PROXY, proxy_);
@@ -73,7 +75,7 @@
// Setup HTTP request method and optional request body.
if (code == CURLE_OK) {
- if (method == request_type::kGet) {
+ if (method == request_type::kGet) {
code = curl_interface_->EasySetOptInt(curl_handle, CURLOPT_HTTPGET, 1);
} else if (method == request_type::kHead) {
code = curl_interface_->EasySetOptInt(curl_handle, CURLOPT_NOBODY, 1);
@@ -83,11 +85,11 @@
// POST and custom request methods
code = curl_interface_->EasySetOptInt(curl_handle, CURLOPT_POST, 1);
if (code == CURLE_OK)
- code = curl_interface_->EasySetOptPtr(curl_handle, CURLOPT_POSTFIELDS,
- nullptr);
+ code = curl_interface_->EasySetOptPtr(
+ curl_handle, CURLOPT_POSTFIELDS, nullptr);
if (code == CURLE_OK && method != request_type::kPost)
- code = curl_interface_->EasySetOptStr(curl_handle,
- CURLOPT_CUSTOMREQUEST, method);
+ code = curl_interface_->EasySetOptStr(
+ curl_handle, CURLOPT_CUSTOMREQUEST, method);
}
}
@@ -134,7 +136,9 @@
const tracked_objects::Location& location,
CURLcode code,
CurlInterface* curl_interface) {
- chromeos::Error::AddTo(error, location, "curl_error",
+ chromeos::Error::AddTo(error,
+ location,
+ "curl_error",
chromeos::string_utils::ToString(code),
curl_interface->EasyStrError(code));
}
diff --git a/chromeos/http/http_transport_curl_unittest.cc b/chromeos/http/http_transport_curl_unittest.cc
index b330182..c427bc5 100644
--- a/chromeos/http/http_transport_curl_unittest.cc
+++ b/chromeos/http/http_transport_curl_unittest.cc
@@ -49,9 +49,12 @@
.WillOnce(Return(CURLE_OK));
EXPECT_CALL(*curl_api_, EasySetOptInt(handle_, CURLOPT_HTTPGET, 1))
.WillOnce(Return(CURLE_OK));
- auto connection = transport_->CreateConnection(
- "http://foo.bar/get", request_type::kGet, {}, "User Agent",
- "http://foo.bar/baz", nullptr);
+ auto connection = transport_->CreateConnection("http://foo.bar/get",
+ request_type::kGet,
+ {},
+ "User Agent",
+ "http://foo.bar/baz",
+ nullptr);
EXPECT_NE(nullptr, connection.get());
EXPECT_CALL(*curl_api_, EasyCleanup(handle_)).Times(1);
@@ -118,8 +121,9 @@
.WillOnce(Return(CURLE_OK));
EXPECT_CALL(*curl_api_, EasySetOptPtr(handle_, CURLOPT_POSTFIELDS, nullptr))
.WillOnce(Return(CURLE_OK));
- EXPECT_CALL(*curl_api_, EasySetOptStr(handle_, CURLOPT_CUSTOMREQUEST,
- request_type::kPatch))
+ EXPECT_CALL(
+ *curl_api_,
+ EasySetOptStr(handle_, CURLOPT_CUSTOMREQUEST, request_type::kPatch))
.WillOnce(Return(CURLE_OK));
auto connection = transport_->CreateConnection(
"http://www.foo.bar/patch", request_type::kPatch, {}, "", "", nullptr);
diff --git a/chromeos/http/http_transport_fake.cc b/chromeos/http/http_transport_fake.cc
index aa8e429..4ef4080 100644
--- a/chromeos/http/http_transport_fake.cc
+++ b/chromeos/http/http_transport_fake.cc
@@ -46,12 +46,12 @@
}
HeaderList headers_copy = headers;
if (!user_agent.empty()) {
- headers_copy.push_back(std::make_pair(http::request_header::kUserAgent,
- user_agent));
+ headers_copy.push_back(
+ std::make_pair(http::request_header::kUserAgent, user_agent));
}
if (!referer.empty()) {
- headers_copy.push_back(std::make_pair(http::request_header::kReferer,
- referer));
+ headers_copy.push_back(
+ std::make_pair(http::request_header::kReferer, referer));
}
connection =
std::make_shared<http::fake::Connection>(url, method, shared_from_this());
@@ -79,7 +79,8 @@
return method + ":" + url;
}
-void Transport::AddHandler(const std::string& url, const std::string& method,
+void Transport::AddHandler(const std::string& url,
+ const std::string& method,
const HandlerCallback& handler) {
handlers_.insert(std::make_pair(GetHandlerMapKey(url, method), handler));
}
@@ -97,7 +98,8 @@
}
Transport::HandlerCallback Transport::GetHandler(
- const std::string& url, const std::string& method) const {
+ const std::string& url,
+ const std::string& method) const {
// First try the exact combination of URL/Method
auto p = handlers_.find(GetHandlerMapKey(url, method));
if (p != handlers_.end())
@@ -137,7 +139,7 @@
}
std::unique_ptr<base::DictionaryValue>
- ServerRequestResponseBase::GetDataAsJson() const {
+ServerRequestResponseBase::GetDataAsJson() const {
if (chromeos::mime::RemoveParameters(
GetHeader(request_header::kContentType)) ==
chromeos::mime::application::kJson) {
@@ -169,8 +171,8 @@
return p != headers_.end() ? p->second : std::string();
}
-ServerRequest::ServerRequest(const std::string& url,
- const std::string& method) : method_(method) {
+ServerRequest::ServerRequest(const std::string& url, const std::string& method)
+ : method_(method) {
auto params = chromeos::url::GetQueryStringParameters(url);
url_ = chromeos::url::RemoveQueryString(url, true);
form_fields_.insert(params.begin(), params.end());
@@ -199,11 +201,9 @@
status_code_ = status_code;
SetData(std::unique_ptr<DataReaderInterface>{
new MemoryDataReader{data, data_size}});
- AddHeaders({
- {response_header::kContentLength,
- chromeos::string_utils::ToString(data_size)},
- {response_header::kContentType, mime_type}
- });
+ AddHeaders({{response_header::kContentLength,
+ chromeos::string_utils::ToString(data_size)},
+ {response_header::kContentType, mime_type}});
}
void ServerResponse::ReplyText(int status_code,
@@ -214,13 +214,12 @@
void ServerResponse::ReplyJson(int status_code, const base::Value* json) {
std::string text;
- base::JSONWriter::WriteWithOptions(json,
- base::JSONWriter::OPTIONS_PRETTY_PRINT,
- &text);
- std::string mime_type = chromeos::mime::AppendParameter(
- chromeos::mime::application::kJson,
- chromeos::mime::parameters::kCharset,
- "utf-8");
+ base::JSONWriter::WriteWithOptions(
+ json, base::JSONWriter::OPTIONS_PRETTY_PRINT, &text);
+ std::string mime_type =
+ chromeos::mime::AppendParameter(chromeos::mime::application::kJson,
+ chromeos::mime::parameters::kCharset,
+ "utf-8");
ReplyText(status_code, text, mime_type);
}
@@ -235,52 +234,52 @@
std::string ServerResponse::GetStatusText() const {
static std::vector<std::pair<int, const char*>> status_text_map = {
- {100, "Continue"},
- {101, "Switching Protocols"},
- {102, "Processing"},
- {200, "OK"},
- {201, "Created"},
- {202, "Accepted"},
- {203, "Non-Authoritative Information"},
- {204, "No Content"},
- {205, "Reset Content"},
- {206, "Partial Content"},
- {207, "Multi-Status"},
- {208, "Already Reported"},
- {226, "IM Used"},
- {300, "Multiple Choices"},
- {301, "Moved Permanently"},
- {302, "Found"},
- {303, "See Other"},
- {304, "Not Modified"},
- {305, "Use Proxy"},
- {306, "Switch Proxy"},
- {307, "Temporary Redirect"},
- {308, "Permanent Redirect"},
- {400, "Bad Request"},
- {401, "Unauthorized"},
- {402, "Payment Required"},
- {403, "Forbidden"},
- {404, "Not Found"},
- {405, "Method Not Allowed"},
- {406, "Not Acceptable"},
- {407, "Proxy Authentication Required"},
- {408, "Request Timeout"},
- {409, "Conflict"},
- {410, "Gone"},
- {411, "Length Required"},
- {412, "Precondition Failed"},
- {413, "Request Entity Too Large"},
- {414, "Request - URI Too Long"},
- {415, "Unsupported Media Type"},
- {429, "Too Many Requests"},
- {431, "Request Header Fields Too Large"},
- {500, "Internal Server Error"},
- {501, "Not Implemented"},
- {502, "Bad Gateway"},
- {503, "Service Unavailable"},
- {504, "Gateway Timeout"},
- {505, "HTTP Version Not Supported"},
+ {100, "Continue"},
+ {101, "Switching Protocols"},
+ {102, "Processing"},
+ {200, "OK"},
+ {201, "Created"},
+ {202, "Accepted"},
+ {203, "Non-Authoritative Information"},
+ {204, "No Content"},
+ {205, "Reset Content"},
+ {206, "Partial Content"},
+ {207, "Multi-Status"},
+ {208, "Already Reported"},
+ {226, "IM Used"},
+ {300, "Multiple Choices"},
+ {301, "Moved Permanently"},
+ {302, "Found"},
+ {303, "See Other"},
+ {304, "Not Modified"},
+ {305, "Use Proxy"},
+ {306, "Switch Proxy"},
+ {307, "Temporary Redirect"},
+ {308, "Permanent Redirect"},
+ {400, "Bad Request"},
+ {401, "Unauthorized"},
+ {402, "Payment Required"},
+ {403, "Forbidden"},
+ {404, "Not Found"},
+ {405, "Method Not Allowed"},
+ {406, "Not Acceptable"},
+ {407, "Proxy Authentication Required"},
+ {408, "Request Timeout"},
+ {409, "Conflict"},
+ {410, "Gone"},
+ {411, "Length Required"},
+ {412, "Precondition Failed"},
+ {413, "Request Entity Too Large"},
+ {414, "Request - URI Too Long"},
+ {415, "Unsupported Media Type"},
+ {429, "Too Many Requests"},
+ {431, "Request Header Fields Too Large"},
+ {500, "Internal Server Error"},
+ {501, "Not Implemented"},
+ {502, "Bad Gateway"},
+ {503, "Service Unavailable"},
+ {504, "Gateway Timeout"},
+ {505, "HTTP Version Not Supported"},
};
for (const auto& pair : status_text_map) {
diff --git a/chromeos/http/http_transport_fake.h b/chromeos/http/http_transport_fake.h
index ee6022a..20fed83 100644
--- a/chromeos/http/http_transport_fake.h
+++ b/chromeos/http/http_transport_fake.h
@@ -175,10 +175,13 @@
ServerResponse() = default;
// Generic reply method.
- void Reply(int status_code, const void* data, size_t data_size,
+ void Reply(int status_code,
+ const void* data,
+ size_t data_size,
const std::string& mime_type);
// Reply with text body.
- void ReplyText(int status_code, const std::string& text,
+ void ReplyText(int status_code,
+ const std::string& text,
const std::string& mime_type);
// Reply with JSON object. The content type will be "application/json".
void ReplyJson(int status_code, const base::Value* json);
@@ -190,7 +193,8 @@
// data elements. Only trivial data types (scalars, POD structures, etc)
// can be used.
template<typename T>
- void Reply(int status_code, const std::vector<T>& data,
+ void Reply(int status_code,
+ const std::vector<T>& data,
const std::string& mime_type) {
// Make sure T doesn't have virtual functions, custom constructors, etc.
static_assert(std::is_trivial<T>::value, "Only simple data is supported");
diff --git a/chromeos/http/http_utils.cc b/chromeos/http/http_utils.cc
index 0cecbf8..6d93b5d 100644
--- a/chromeos/http/http_utils.cc
+++ b/chromeos/http/http_utils.cc
@@ -32,8 +32,8 @@
const HeaderList& headers,
std::shared_ptr<Transport> transport,
chromeos::ErrorPtr* error) {
- return SendRequestWithNoDataAndBlock(request_type::kGet, url, headers,
- transport, error);
+ return SendRequestWithNoDataAndBlock(
+ request_type::kGet, url, headers, transport, error);
}
void Get(const std::string& url,
@@ -41,8 +41,12 @@
std::shared_ptr<Transport> transport,
const SuccessCallback& success_callback,
const ErrorCallback& error_callback) {
- SendRequestWithNoData(request_type::kGet, url, headers, transport,
- success_callback, error_callback);
+ SendRequestWithNoData(request_type::kGet,
+ url,
+ headers,
+ transport,
+ success_callback,
+ error_callback);
}
std::string GetAsStringAndBlock(const std::string& url,
@@ -59,7 +63,9 @@
std::shared_ptr<Transport> transport,
const base::Callback<void(const std::string&)>& success_callback,
const ErrorCallback& error_callback) {
- Get(url, headers, transport,
+ Get(url,
+ headers,
+ transport,
base::Bind(SuccessCallbackStringWrapper, success_callback),
error_callback);
}
@@ -67,16 +73,20 @@
std::unique_ptr<Response> HeadAndBlock(const std::string& url,
std::shared_ptr<Transport> transport,
chromeos::ErrorPtr* error) {
- return SendRequestWithNoDataAndBlock(request_type::kHead, url, {}, transport,
- error);
+ return SendRequestWithNoDataAndBlock(
+ request_type::kHead, url, {}, transport, error);
}
void Head(const std::string& url,
std::shared_ptr<Transport> transport,
const SuccessCallback& success_callback,
const ErrorCallback& error_callback) {
- SendRequestWithNoData(request_type::kHead, url, {}, transport,
- success_callback, error_callback);
+ SendRequestWithNoData(request_type::kHead,
+ url,
+ {},
+ transport,
+ success_callback,
+ error_callback);
}
std::unique_ptr<Response> PostTextAndBlock(const std::string& url,
@@ -85,8 +95,8 @@
const HeaderList& headers,
std::shared_ptr<Transport> transport,
chromeos::ErrorPtr* error) {
- return PostBinaryAndBlock(url, data.data(), data.size(), mime_type, headers,
- transport, error);
+ return PostBinaryAndBlock(
+ url, data.data(), data.size(), mime_type, headers, transport, error);
}
void PostText(const std::string& url,
@@ -96,8 +106,14 @@
std::shared_ptr<Transport> transport,
const SuccessCallback& success_callback,
const ErrorCallback& error_callback) {
- PostBinary(url, data.data(), data.size(), mime_type, headers, transport,
- success_callback, error_callback);
+ PostBinary(url,
+ data.data(),
+ data.size(),
+ mime_type,
+ headers,
+ transport,
+ success_callback,
+ error_callback);
}
std::unique_ptr<Response> SendRequestAndBlock(
@@ -127,19 +143,18 @@
const HeaderList& headers,
std::shared_ptr<Transport> transport,
chromeos::ErrorPtr* error) {
- return SendRequestAndBlock(method, url, nullptr, 0, {}, headers, transport,
- error);
+ return SendRequestAndBlock(
+ method, url, nullptr, 0, {}, headers, transport, error);
}
-void SendRequest(
- const std::string& method,
- const std::string& url,
- std::unique_ptr<DataReaderInterface> data_reader,
- const std::string& mime_type,
- const HeaderList& headers,
- std::shared_ptr<Transport> transport,
- const SuccessCallback& success_callback,
- const ErrorCallback& error_callback) {
+void SendRequest(const std::string& method,
+ const std::string& url,
+ std::unique_ptr<DataReaderInterface> data_reader,
+ const std::string& mime_type,
+ const HeaderList& headers,
+ std::shared_ptr<Transport> transport,
+ const SuccessCallback& success_callback,
+ const ErrorCallback& error_callback) {
Request request(url, method, transport);
request.AddHeaders(headers);
if (data_reader && data_reader->GetDataSize() > 0) {
@@ -148,40 +163,48 @@
request.SetContentType(mime_type);
chromeos::ErrorPtr error;
if (!request.AddRequestBody(std::move(data_reader), &error)) {
- transport->RunCallbackAsync(FROM_HERE,
- base::Bind(error_callback,
- base::Owned(error.release())));
+ transport->RunCallbackAsync(
+ FROM_HERE, base::Bind(error_callback, base::Owned(error.release())));
return;
}
}
request.GetResponse(success_callback, error_callback);
}
-void SendRequest(
- const std::string& method,
- const std::string& url,
- const void* data,
- size_t data_size,
- const std::string& mime_type,
- const HeaderList& headers,
- std::shared_ptr<Transport> transport,
- const SuccessCallback& success_callback,
- const ErrorCallback& error_callback) {
+void SendRequest(const std::string& method,
+ const std::string& url,
+ const void* data,
+ size_t data_size,
+ const std::string& mime_type,
+ const HeaderList& headers,
+ std::shared_ptr<Transport> transport,
+ const SuccessCallback& success_callback,
+ const ErrorCallback& error_callback) {
std::unique_ptr<DataReaderInterface> data_reader{
- new MemoryDataReader(data, data_size)
- };
- SendRequest(method, url, std::move(data_reader), mime_type, headers,
- transport, success_callback, error_callback);
+ new MemoryDataReader(data, data_size)};
+ SendRequest(method,
+ url,
+ std::move(data_reader),
+ mime_type,
+ headers,
+ transport,
+ success_callback,
+ error_callback);
}
-void SendRequestWithNoData(
- const std::string& method,
- const std::string& url,
- const HeaderList& headers,
- std::shared_ptr<Transport> transport,
- const SuccessCallback& success_callback,
- const ErrorCallback& error_callback) {
- SendRequest(method, url, {}, {}, headers, transport, success_callback,
+void SendRequestWithNoData(const std::string& method,
+ const std::string& url,
+ const HeaderList& headers,
+ std::shared_ptr<Transport> transport,
+ const SuccessCallback& success_callback,
+ const ErrorCallback& error_callback) {
+ SendRequest(method,
+ url,
+ {},
+ {},
+ headers,
+ transport,
+ success_callback,
error_callback);
}
@@ -193,33 +216,50 @@
const HeaderList& headers,
std::shared_ptr<Transport> transport,
chromeos::ErrorPtr* error) {
- return SendRequestAndBlock(request_type::kPost, url, data, data_size,
- mime_type, headers, transport, error);
+ return SendRequestAndBlock(request_type::kPost,
+ url,
+ data,
+ data_size,
+ mime_type,
+ headers,
+ transport,
+ error);
}
-void PostBinary(
- const std::string& url,
- std::unique_ptr<DataReaderInterface> data_reader,
- const std::string& mime_type,
- const HeaderList& headers,
- std::shared_ptr<Transport> transport,
- const SuccessCallback& success_callback,
- const ErrorCallback& error_callback) {
- SendRequest(request_type::kPost, url, std::move(data_reader), mime_type,
- headers, transport, success_callback, error_callback);
+void PostBinary(const std::string& url,
+ std::unique_ptr<DataReaderInterface> data_reader,
+ const std::string& mime_type,
+ const HeaderList& headers,
+ std::shared_ptr<Transport> transport,
+ const SuccessCallback& success_callback,
+ const ErrorCallback& error_callback) {
+ SendRequest(request_type::kPost,
+ url,
+ std::move(data_reader),
+ mime_type,
+ headers,
+ transport,
+ success_callback,
+ error_callback);
}
-void PostBinary(
- const std::string& url,
- const void* data,
- size_t data_size,
- const std::string& mime_type,
- const HeaderList& headers,
- std::shared_ptr<Transport> transport,
- const SuccessCallback& success_callback,
- const ErrorCallback& error_callback) {
- SendRequest(request_type::kPost, url, data, data_size, mime_type,
- headers, transport, success_callback, error_callback);
+void PostBinary(const std::string& url,
+ const void* data,
+ size_t data_size,
+ const std::string& mime_type,
+ const HeaderList& headers,
+ std::shared_ptr<Transport> transport,
+ const SuccessCallback& success_callback,
+ const ErrorCallback& error_callback) {
+ SendRequest(request_type::kPost,
+ url,
+ data,
+ data_size,
+ mime_type,
+ headers,
+ transport,
+ success_callback,
+ error_callback);
}
std::unique_ptr<Response> PostFormDataAndBlock(
@@ -229,9 +269,13 @@
std::shared_ptr<Transport> transport,
chromeos::ErrorPtr* error) {
std::string encoded_data = chromeos::data_encoding::WebParamsEncode(data);
- return PostBinaryAndBlock(url, encoded_data.c_str(), encoded_data.size(),
+ return PostBinaryAndBlock(url,
+ encoded_data.c_str(),
+ encoded_data.size(),
chromeos::mime::application::kWwwFormUrlEncoded,
- headers, transport, error);
+ headers,
+ transport,
+ error);
}
std::unique_ptr<Response> PostFormDataAndBlock(
@@ -247,69 +291,75 @@
return request.GetResponseAndBlock(error);
}
-void PostFormData(
- const std::string& url,
- const FormFieldList& data,
- const HeaderList& headers,
- std::shared_ptr<Transport> transport,
- const SuccessCallback& success_callback,
- const ErrorCallback& error_callback) {
+void PostFormData(const std::string& url,
+ const FormFieldList& data,
+ const HeaderList& headers,
+ std::shared_ptr<Transport> transport,
+ const SuccessCallback& success_callback,
+ const ErrorCallback& error_callback) {
std::string encoded_data = chromeos::data_encoding::WebParamsEncode(data);
- return PostBinary(url, encoded_data.c_str(), encoded_data.size(),
+ return PostBinary(url,
+ encoded_data.c_str(),
+ encoded_data.size(),
chromeos::mime::application::kWwwFormUrlEncoded,
- headers, transport, success_callback, error_callback);
+ headers,
+ transport,
+ success_callback,
+ error_callback);
}
-void PostFormData(
- const std::string& url,
- std::unique_ptr<FormData> form_data,
- const HeaderList& headers,
- std::shared_ptr<Transport> transport,
- const SuccessCallback& success_callback,
- const ErrorCallback& error_callback) {
+void PostFormData(const std::string& url,
+ std::unique_ptr<FormData> form_data,
+ const HeaderList& headers,
+ std::shared_ptr<Transport> transport,
+ const SuccessCallback& success_callback,
+ const ErrorCallback& error_callback) {
Request request(url, request_type::kPost, transport);
request.AddHeaders(headers);
chromeos::ErrorPtr error;
if (!request.AddRequestBodyAsFormData(std::move(form_data), &error)) {
- transport->RunCallbackAsync(FROM_HERE,
- base::Bind(error_callback,
- base::Owned(error.release())));
+ transport->RunCallbackAsync(
+ FROM_HERE, base::Bind(error_callback, base::Owned(error.release())));
return;
}
request.GetResponse(success_callback, error_callback);
}
-std::unique_ptr<Response> PostJsonAndBlock(
- const std::string& url,
- const base::Value* json,
- const HeaderList& headers,
- std::shared_ptr<Transport> transport,
- chromeos::ErrorPtr* error) {
+std::unique_ptr<Response> PostJsonAndBlock(const std::string& url,
+ const base::Value* json,
+ const HeaderList& headers,
+ std::shared_ptr<Transport> transport,
+ chromeos::ErrorPtr* error) {
std::string data;
if (json)
base::JSONWriter::Write(json, &data);
std::string mime_type = AppendParameter(chromeos::mime::application::kJson,
chromeos::mime::parameters::kCharset,
"utf-8");
- return PostBinaryAndBlock(url, data.c_str(), data.size(),
- mime_type, headers, transport, error);
+ return PostBinaryAndBlock(
+ url, data.c_str(), data.size(), mime_type, headers, transport, error);
}
-void PostJson(
- const std::string& url,
- std::unique_ptr<base::Value> json,
- const HeaderList& headers,
- std::shared_ptr<Transport> transport,
- const SuccessCallback& success_callback,
- const ErrorCallback& error_callback) {
+void PostJson(const std::string& url,
+ std::unique_ptr<base::Value> json,
+ const HeaderList& headers,
+ std::shared_ptr<Transport> transport,
+ const SuccessCallback& success_callback,
+ const ErrorCallback& error_callback) {
std::string data;
if (json)
base::JSONWriter::Write(json.get(), &data);
std::string mime_type = AppendParameter(chromeos::mime::application::kJson,
chromeos::mime::parameters::kCharset,
"utf-8");
- PostBinary(url, data.c_str(), data.size(), mime_type, headers, transport,
- success_callback, error_callback);
+ PostBinary(url,
+ data.c_str(),
+ data.size(),
+ mime_type,
+ headers,
+ transport,
+ success_callback,
+ error_callback);
}
std::unique_ptr<Response> PatchJsonAndBlock(
@@ -324,30 +374,43 @@
std::string mime_type = AppendParameter(chromeos::mime::application::kJson,
chromeos::mime::parameters::kCharset,
"utf-8");
- return SendRequestAndBlock(request_type::kPatch, url, data.c_str(),
- data.size(), mime_type, headers, transport, error);
+ return SendRequestAndBlock(request_type::kPatch,
+ url,
+ data.c_str(),
+ data.size(),
+ mime_type,
+ headers,
+ transport,
+ error);
}
-void PatchJson(
- const std::string& url,
- std::unique_ptr<base::Value> json,
- const HeaderList& headers,
- std::shared_ptr<Transport> transport,
- const SuccessCallback& success_callback,
- const ErrorCallback& error_callback) {
+void PatchJson(const std::string& url,
+ std::unique_ptr<base::Value> json,
+ const HeaderList& headers,
+ std::shared_ptr<Transport> transport,
+ const SuccessCallback& success_callback,
+ const ErrorCallback& error_callback) {
std::string data;
if (json)
base::JSONWriter::Write(json.get(), &data);
std::string mime_type = AppendParameter(chromeos::mime::application::kJson,
chromeos::mime::parameters::kCharset,
"utf-8");
- SendRequest(request_type::kPatch, url, data.c_str(), data.size(),
- mime_type, headers, transport,
- success_callback, error_callback);
+ SendRequest(request_type::kPatch,
+ url,
+ data.c_str(),
+ data.size(),
+ mime_type,
+ headers,
+ transport,
+ success_callback,
+ error_callback);
}
std::unique_ptr<base::DictionaryValue> ParseJsonResponse(
- const Response* response, int* status_code, chromeos::ErrorPtr* error) {
+ const Response* response,
+ int* status_code,
+ chromeos::ErrorPtr* error) {
if (!response)
return std::unique_ptr<base::DictionaryValue>();
@@ -359,7 +422,9 @@
auto content_type = RemoveParameters(response->GetContentType());
if (content_type != chromeos::mime::application::kJson &&
content_type != chromeos::mime::text::kPlain) {
- chromeos::Error::AddTo(error, FROM_HERE, chromeos::errors::json::kDomain,
+ chromeos::Error::AddTo(error,
+ FROM_HERE,
+ chromeos::errors::json::kDomain,
"non_json_content_type",
"Unexpected response content type: " + content_type);
return std::unique_ptr<base::DictionaryValue>();
@@ -370,14 +435,19 @@
base::Value* value = base::JSONReader::ReadAndReturnError(
json, base::JSON_PARSE_RFC, nullptr, &error_message);
if (!value) {
- chromeos::Error::AddTo(error, FROM_HERE, chromeos::errors::json::kDomain,
- chromeos::errors::json::kParseError, error_message);
+ chromeos::Error::AddTo(error,
+ FROM_HERE,
+ chromeos::errors::json::kDomain,
+ chromeos::errors::json::kParseError,
+ error_message);
return std::unique_ptr<base::DictionaryValue>();
}
base::DictionaryValue* dict_value = nullptr;
if (!value->GetAsDictionary(&dict_value)) {
delete value;
- chromeos::Error::AddTo(error, FROM_HERE, chromeos::errors::json::kDomain,
+ chromeos::Error::AddTo(error,
+ FROM_HERE,
+ chromeos::errors::json::kDomain,
chromeos::errors::json::kObjectExpected,
"Response is not a valid JSON object");
return std::unique_ptr<base::DictionaryValue>();
diff --git a/chromeos/http/http_utils_unittest.cc b/chromeos/http/http_utils_unittest.cc
index 590bd02..1b6abbb 100644
--- a/chromeos/http/http_utils_unittest.cc
+++ b/chromeos/http/http_utils_unittest.cc
@@ -25,28 +25,35 @@
// Returns the request data back with the same content type.
static void EchoDataHandler(const fake::ServerRequest& request,
fake::ServerResponse* response) {
- response->Reply(status_code::Ok, request.GetData(),
+ response->Reply(status_code::Ok,
+ request.GetData(),
request.GetHeader(request_header::kContentType));
}
// Returns the request method as a plain text response.
static void EchoMethodHandler(const fake::ServerRequest& request,
fake::ServerResponse* response) {
- response->ReplyText(status_code::Ok, request.GetMethod(),
- chromeos::mime::text::kPlain);
+ response->ReplyText(
+ status_code::Ok, request.GetMethod(), chromeos::mime::text::kPlain);
}
///////////////////////////////////////////////////////////////////////////////
TEST(HttpUtils, SendRequest_BinaryData) {
std::shared_ptr<fake::Transport> transport(new fake::Transport);
- transport->AddHandler(kEchoUrl, request_type::kPost,
- base::Bind(EchoDataHandler));
+ transport->AddHandler(
+ kEchoUrl, request_type::kPost, base::Bind(EchoDataHandler));
// Test binary data round-tripping.
std::vector<uint8_t> custom_data{0xFF, 0x00, 0x80, 0x40, 0xC0, 0x7F};
- auto response = http::SendRequestAndBlock(
- request_type::kPost, kEchoUrl, custom_data.data(), custom_data.size(),
- chromeos::mime::application::kOctet_stream, {}, transport, nullptr);
+ auto response =
+ http::SendRequestAndBlock(request_type::kPost,
+ kEchoUrl,
+ custom_data.data(),
+ custom_data.size(),
+ chromeos::mime::application::kOctet_stream,
+ {},
+ transport,
+ nullptr);
EXPECT_TRUE(response->IsSuccessful());
EXPECT_EQ(chromeos::mime::application::kOctet_stream,
response->GetContentType());
@@ -56,8 +63,8 @@
TEST(HttpUtils, SendRequestAsync_BinaryData) {
std::shared_ptr<fake::Transport> transport(new fake::Transport);
- transport->AddHandler(kEchoUrl, request_type::kPost,
- base::Bind(EchoDataHandler));
+ transport->AddHandler(
+ kEchoUrl, request_type::kPost, base::Bind(EchoDataHandler));
// Test binary data round-tripping.
std::vector<uint8_t> custom_data{0xFF, 0x00, 0x80, 0x40, 0xC0, 0x7F};
@@ -71,10 +78,15 @@
auto error_callback = [](const Error* error) {
FAIL() << "This callback shouldn't have been called";
};
- http::SendRequest(
- request_type::kPost, kEchoUrl, custom_data.data(), custom_data.size(),
- chromeos::mime::application::kOctet_stream, {}, transport,
- base::Bind(success_callback), base::Bind(error_callback));
+ http::SendRequest(request_type::kPost,
+ kEchoUrl,
+ custom_data.data(),
+ custom_data.size(),
+ chromeos::mime::application::kOctet_stream,
+ {},
+ transport,
+ base::Bind(success_callback),
+ base::Bind(error_callback));
}
TEST(HttpUtils, SendRequest_Post) {
@@ -85,10 +97,15 @@
std::vector<uint8_t> custom_data{0xFF, 0x00, 0x80, 0x40, 0xC0, 0x7F};
// Check the correct HTTP method used.
- auto response = http::SendRequestAndBlock(
- request_type::kPost, kMethodEchoUrl, custom_data.data(),
- custom_data.size(), chromeos::mime::application::kOctet_stream, {},
- transport, nullptr);
+ auto response =
+ http::SendRequestAndBlock(request_type::kPost,
+ kMethodEchoUrl,
+ custom_data.data(),
+ custom_data.size(),
+ chromeos::mime::application::kOctet_stream,
+ {},
+ transport,
+ nullptr);
EXPECT_TRUE(response->IsSuccessful());
EXPECT_EQ(chromeos::mime::text::kPlain, response->GetContentType());
EXPECT_EQ(request_type::kPost, response->GetDataAsString());
@@ -98,9 +115,14 @@
std::shared_ptr<fake::Transport> transport(new fake::Transport);
transport->AddHandler(kMethodEchoUrl, "*", base::Bind(EchoMethodHandler));
- auto response = http::SendRequestAndBlock(
- request_type::kGet, kMethodEchoUrl, nullptr, 0, std::string{}, {},
- transport, nullptr);
+ auto response = http::SendRequestAndBlock(request_type::kGet,
+ kMethodEchoUrl,
+ nullptr,
+ 0,
+ std::string{},
+ {},
+ transport,
+ nullptr);
EXPECT_TRUE(response->IsSuccessful());
EXPECT_EQ(chromeos::mime::text::kPlain, response->GetContentType());
EXPECT_EQ(request_type::kGet, response->GetDataAsString());
@@ -110,9 +132,14 @@
std::shared_ptr<fake::Transport> transport(new fake::Transport);
transport->AddHandler(kMethodEchoUrl, "*", base::Bind(EchoMethodHandler));
- auto response = http::SendRequestAndBlock(
- request_type::kPut, kMethodEchoUrl, nullptr, 0, std::string{}, {},
- transport, nullptr);
+ auto response = http::SendRequestAndBlock(request_type::kPut,
+ kMethodEchoUrl,
+ nullptr,
+ 0,
+ std::string{},
+ {},
+ transport,
+ nullptr);
EXPECT_TRUE(response->IsSuccessful());
EXPECT_EQ(chromeos::mime::text::kPlain, response->GetContentType());
EXPECT_EQ(request_type::kPut, response->GetDataAsString());
@@ -137,17 +164,20 @@
auto error_callback = [](const Error* error) {
FAIL() << "This callback shouldn't have been called";
};
- http::SendRequestWithNoData(
- request_type::kGet, "http://blah.com", {}, transport,
- base::Bind(success_callback), base::Bind(error_callback));
+ http::SendRequestWithNoData(request_type::kGet,
+ "http://blah.com",
+ {},
+ transport,
+ base::Bind(success_callback),
+ base::Bind(error_callback));
}
TEST(HttpUtils, SendRequest_Headers) {
std::shared_ptr<fake::Transport> transport(new fake::Transport);
static const char json_echo_url[] = "http://localhost/echo/json";
- auto JsonEchoHandler = [](const fake::ServerRequest& request,
- fake::ServerResponse* response) {
+ auto JsonEchoHandler =
+ [](const fake::ServerRequest& request, fake::ServerResponse* response) {
base::DictionaryValue json;
json.SetString("method", request.GetMethod());
json.SetString("data", request.GetDataAsString());
@@ -156,8 +186,7 @@
}
response->ReplyJson(status_code::Ok, &json);
};
- transport->AddHandler(json_echo_url, "*",
- base::Bind(JsonEchoHandler));
+ transport->AddHandler(json_echo_url, "*", base::Bind(JsonEchoHandler));
auto response = http::SendRequestAndBlock(
request_type::kPost, json_echo_url, "abcd", 4,
chromeos::mime::application::kOctet_stream, {
@@ -187,12 +216,13 @@
// Sends back the "?test=..." portion of URL.
// So if we do GET "http://localhost?test=blah", this handler responds
// with "blah" as text/plain.
- auto GetHandler = [](const fake::ServerRequest& request,
- fake::ServerResponse* response) {
+ auto GetHandler =
+ [](const fake::ServerRequest& request, fake::ServerResponse* response) {
EXPECT_EQ(request_type::kGet, request.GetMethod());
EXPECT_EQ("0", request.GetHeader(request_header::kContentLength));
EXPECT_EQ("", request.GetHeader(request_header::kContentType));
- response->ReplyText(status_code::Ok, request.GetFormField("test"),
+ response->ReplyText(status_code::Ok,
+ request.GetFormField("test"),
chromeos::mime::text::kPlain);
};
@@ -215,13 +245,12 @@
}
TEST(HttpUtils, Head) {
- auto HeadHandler = [](const fake::ServerRequest& request,
- fake::ServerResponse* response) {
+ auto HeadHandler =
+ [](const fake::ServerRequest& request, fake::ServerResponse* response) {
EXPECT_EQ(request_type::kHead, request.GetMethod());
EXPECT_EQ("0", request.GetHeader(request_header::kContentLength));
EXPECT_EQ("", request.GetHeader(request_header::kContentType));
- response->ReplyText(status_code::Ok, "blah",
- chromeos::mime::text::kPlain);
+ response->ReplyText(status_code::Ok, "blah", chromeos::mime::text::kPlain);
};
std::shared_ptr<fake::Transport> transport(new fake::Transport);
@@ -235,8 +264,8 @@
}
TEST(HttpUtils, PostBinary) {
- auto Handler = [](const fake::ServerRequest& request,
- fake::ServerResponse* response) {
+ auto Handler =
+ [](const fake::ServerRequest& request, fake::ServerResponse* response) {
EXPECT_EQ(request_type::kPost, request.GetMethod());
EXPECT_EQ("256", request.GetHeader(request_header::kContentLength));
EXPECT_EQ(chromeos::mime::application::kOctet_stream,
@@ -257,9 +286,13 @@
std::vector<uint8_t> data(256);
std::iota(data.begin(), data.end(), 0);
- auto response = http::PostBinaryAndBlock(
- kFakeUrl, data.data(), data.size(), mime::application::kOctet_stream, {},
- transport, nullptr);
+ auto response = http::PostBinaryAndBlock(kFakeUrl,
+ data.data(),
+ data.size(),
+ mime::application::kOctet_stream,
+ {},
+ transport,
+ nullptr);
EXPECT_TRUE(response->IsSuccessful());
}
@@ -272,16 +305,20 @@
std::stoul(request.GetHeader(request_header::kContentLength)));
EXPECT_EQ(chromeos::mime::text::kPlain,
request.GetHeader(request_header::kContentType));
- response->ReplyText(status_code::Ok, request.GetDataAsString(),
- chromeos::mime::text::kPlain);
+ response->ReplyText(status_code::Ok,
+ request.GetDataAsString(),
+ chromeos::mime::text::kPlain);
};
std::shared_ptr<fake::Transport> transport(new fake::Transport);
transport->AddHandler(kFakeUrl, request_type::kPost, base::Bind(PostHandler));
- auto response = http::PostTextAndBlock(
- kFakeUrl, fake_data, chromeos::mime::text::kPlain, {}, transport,
- nullptr);
+ auto response = http::PostTextAndBlock(kFakeUrl,
+ fake_data,
+ chromeos::mime::text::kPlain,
+ {},
+ transport,
+ nullptr);
EXPECT_TRUE(response->IsSuccessful());
EXPECT_EQ(chromeos::mime::text::kPlain, response->GetContentType());
EXPECT_EQ(fake_data, response->GetDataAsString());
@@ -289,8 +326,8 @@
TEST(HttpUtils, PostFormData) {
std::shared_ptr<fake::Transport> transport(new fake::Transport);
- transport->AddHandler(kFakeUrl, request_type::kPost,
- base::Bind(EchoDataHandler));
+ transport->AddHandler(
+ kFakeUrl, request_type::kPost, base::Bind(EchoDataHandler));
auto response = http::PostFormDataAndBlock(
kFakeUrl, {
@@ -305,15 +342,15 @@
TEST(HttpUtils, PostMultipartFormData) {
std::shared_ptr<fake::Transport> transport(new fake::Transport);
- transport->AddHandler(kFakeUrl, request_type::kPost,
- base::Bind(EchoDataHandler));
+ transport->AddHandler(
+ kFakeUrl, request_type::kPost, base::Bind(EchoDataHandler));
std::unique_ptr<FormData> form_data{new FormData{"boundary123"}};
form_data->AddTextField("key1", "value1");
form_data->AddTextField("key2", "value2");
std::string expected_content_type = form_data->GetContentType();
- auto response = http::PostFormDataAndBlock(kFakeUrl, std::move(form_data), {},
- transport, nullptr);
+ auto response = http::PostFormDataAndBlock(
+ kFakeUrl, std::move(form_data), {}, transport, nullptr);
EXPECT_TRUE(response->IsSuccessful());
EXPECT_EQ(expected_content_type, response->GetContentType());
const char expected_value[] =
@@ -330,15 +367,16 @@
}
TEST(HttpUtils, PostPatchJson) {
- auto JsonHandler = [](const fake::ServerRequest& request,
- fake::ServerResponse* response) {
+ auto JsonHandler =
+ [](const fake::ServerRequest& request, fake::ServerResponse* response) {
auto mime_type = chromeos::mime::RemoveParameters(
request.GetHeader(request_header::kContentType));
EXPECT_EQ(chromeos::mime::application::kJson, mime_type);
- response->ReplyJson(status_code::Ok, {
- {"method", request.GetMethod()},
- {"data", request.GetDataAsString()},
- });
+ response->ReplyJson(
+ status_code::Ok,
+ {
+ {"method", request.GetMethod()}, {"data", request.GetDataAsString()},
+ });
};
std::shared_ptr<fake::Transport> transport(new fake::Transport);
transport->AddHandler(kFakeUrl, "*", base::Bind(JsonHandler));
@@ -369,8 +407,8 @@
}
TEST(HttpUtils, ParseJsonResponse) {
- auto JsonHandler = [](const fake::ServerRequest& request,
- fake::ServerResponse* response) {
+ auto JsonHandler =
+ [](const fake::ServerRequest& request, fake::ServerResponse* response) {
int status_code = std::stoi(request.GetFormField("code"));
response->ReplyJson(status_code, {{"data", request.GetFormField("value")}});
};
@@ -433,9 +471,12 @@
EXPECT_EQ("test_code", error->GetCode());
EXPECT_EQ("Test message", error->GetMessage());
};
- http::SendRequestWithNoData(
- request_type::kGet, "http://blah.com", {}, transport,
- base::Bind(success_callback), base::Bind(error_callback));
+ http::SendRequestWithNoData(request_type::kGet,
+ "http://blah.com",
+ {},
+ transport,
+ base::Bind(success_callback),
+ base::Bind(error_callback));
}
} // namespace http
diff --git a/chromeos/key_value_store.cc b/chromeos/key_value_store.cc
index 1f614ca..8914229 100644
--- a/chromeos/key_value_store.cc
+++ b/chromeos/key_value_store.cc
@@ -65,7 +65,7 @@
if (key_value->second == "true") {
*value = true;
return true;
- } else if (key_value-> second == "false") {
+ } else if (key_value->second == "false") {
*value = false;
return true;
}
diff --git a/chromeos/key_value_store_unittest.cc b/chromeos/key_value_store_unittest.cc
index 81bc4a0..668cdff 100644
--- a/chromeos/key_value_store_unittest.cc
+++ b/chromeos/key_value_store_unittest.cc
@@ -58,9 +58,12 @@
ASSERT_EQ(blob.size(), base::WriteFile(temp_file_, blob.data(), blob.size()));
EXPECT_TRUE(store_.Load(temp_file_));
- map<string, string> expected = {
- {"A", "B"}, {"C", ""}, {"", ""}, {"FOO", "BAR=BAZ"}, {"BAR", "BAX"},
- {"MISSING", "NEWLINE"}};
+ map<string, string> expected = {{"A", "B"},
+ {"C", ""},
+ {"", ""},
+ {"FOO", "BAR=BAZ"},
+ {"BAR", "BAX"},
+ {"MISSING", "NEWLINE"}};
// Test expected values
string value;
diff --git a/chromeos/map_utils.h b/chromeos/map_utils.h
index b79d1e3..cf4fcd6 100644
--- a/chromeos/map_utils.h
+++ b/chromeos/map_utils.h
@@ -45,7 +45,7 @@
// Given an STL map, returns a vector of key-value pairs from the map.
template<typename T>
inline std::vector<std::pair<typename T::key_type, typename T::mapped_type>>
- MapToVector(const T& map) {
+MapToVector(const T& map) {
std::vector<std::pair<typename T::key_type, typename T::mapped_type>> vector;
vector.reserve(map.size());
for (const auto& pair : map)
@@ -56,10 +56,10 @@
// Given an STL map, returns the value associated with a given key or a default
// value if the key is not present in the map.
template<typename T>
-inline typename T::mapped_type
- GetOrDefault(const T& map,
- typename T::key_type key,
- const typename T::mapped_type& def) {
+inline typename T::mapped_type GetOrDefault(
+ const T& map,
+ typename T::key_type key,
+ const typename T::mapped_type& def) {
typename T::const_iterator it = map.find(key);
if (it == map.end())
return def;
diff --git a/chromeos/map_utils_unittest.cc b/chromeos/map_utils_unittest.cc
index 5b796fa..b04620e 100644
--- a/chromeos/map_utils_unittest.cc
+++ b/chromeos/map_utils_unittest.cc
@@ -14,17 +14,11 @@
public:
void SetUp() override {
map_ = {
- {"key1", 1},
- {"key2", 2},
- {"key3", 3},
- {"key4", 4},
- {"key5", 5},
+ {"key1", 1}, {"key2", 2}, {"key3", 3}, {"key4", 4}, {"key5", 5},
};
}
- void TearDown() override {
- map_.clear();
- }
+ void TearDown() override { map_.clear(); }
std::map<std::string, int> map_;
};
@@ -49,11 +43,7 @@
TEST_F(MapUtilsTest, MapToVector) {
std::vector<std::pair<std::string, int>> elements = MapToVector(map_);
std::vector<std::pair<std::string, int>> expected{
- {"key1", 1},
- {"key2", 2},
- {"key3", 3},
- {"key4", 4},
- {"key5", 5},
+ {"key1", 1}, {"key2", 2}, {"key3", 3}, {"key4", 4}, {"key5", 5},
};
EXPECT_EQ(expected, elements);
}
diff --git a/chromeos/mime_utils.cc b/chromeos/mime_utils.cc
index a40a2f4..5e2263a 100644
--- a/chromeos/mime_utils.cc
+++ b/chromeos/mime_utils.cc
@@ -66,10 +66,11 @@
// ***************************************************************************
bool mime::Split(const std::string& mime_string,
- std::string* type, std::string* subtype,
+ std::string* type,
+ std::string* subtype,
mime::Parameters* parameters) {
- std::vector<std::string> parts = chromeos::string_utils::Split(mime_string,
- ';');
+ std::vector<std::string> parts =
+ chromeos::string_utils::Split(mime_string, ';');
if (parts.empty())
return false;
@@ -89,7 +90,8 @@
}
bool mime::Split(const std::string& mime_string,
- std::string* type, std::string* subtype) {
+ std::string* type,
+ std::string* subtype) {
std::string mime = mime::RemoveParameters(mime_string);
auto types = chromeos::string_utils::SplitAtFirst(mime, '/');
@@ -102,14 +104,14 @@
return !types.first.empty() && !types.second.empty();
}
-std::string mime::Combine(const std::string& type, const std::string& subtype,
+std::string mime::Combine(const std::string& type,
+ const std::string& subtype,
const mime::Parameters& parameters) {
std::vector<std::string> parts;
parts.push_back(chromeos::string_utils::Join('/', type, subtype));
for (const auto& pair : parameters) {
- parts.push_back(chromeos::string_utils::Join('=',
- pair.first,
- EncodeParam(pair.second)));
+ parts.push_back(chromeos::string_utils::Join(
+ '=', pair.first, EncodeParam(pair.second)));
}
return chromeos::string_utils::Join("; ", parts);
}
diff --git a/chromeos/mime_utils.h b/chromeos/mime_utils.h
index e8b8685..46d4b88 100644
--- a/chromeos/mime_utils.h
+++ b/chromeos/mime_utils.h
@@ -81,7 +81,8 @@
// Splits a MIME string into type and subtype.
// "text/plain;charset=utf-8" => ("text", "plain")
CHROMEOS_EXPORT bool Split(const std::string& mime_string,
- std::string* type, std::string* subtype);
+ std::string* type,
+ std::string* subtype);
// Splits a MIME string into type, subtype, and parameters.
// "text/plain;charset=utf-8" => ("text", "plain", {{"charset","utf-8"}})
diff --git a/chromeos/mime_utils_unittest.cc b/chromeos/mime_utils_unittest.cc
index ac9292b..751d7fd 100644
--- a/chromeos/mime_utils_unittest.cc
+++ b/chromeos/mime_utils_unittest.cc
@@ -11,9 +11,9 @@
TEST(MimeUtils, Combine) {
std::string mime_string = mime::Combine(mime::types::kText, "xml");
EXPECT_EQ(mime::text::kXml, mime_string);
- EXPECT_EQ("application/json; charset=utf-8",
- mime::Combine(mime::types::kApplication, "json",
- {{"charset", "utf-8"}}));
+ EXPECT_EQ(
+ "application/json; charset=utf-8",
+ mime::Combine(mime::types::kApplication, "json", {{"charset", "utf-8"}}));
}
TEST(MimeUtils, Split) {
@@ -23,8 +23,8 @@
EXPECT_EQ("jpeg", s2);
mime::Parameters parameters;
- EXPECT_TRUE(mime::Split("application/json;charset=utf-8",
- &s1, &s2, ¶meters));
+ EXPECT_TRUE(
+ mime::Split("application/json;charset=utf-8", &s1, &s2, ¶meters));
EXPECT_EQ(mime::types::kApplication, s1);
EXPECT_EQ("json", s2);
EXPECT_EQ(mime::application::kJson, mime::Combine(s1, s2));
@@ -50,14 +50,13 @@
}
TEST(MimeUtils, AppendRemoveParams) {
- std::string mime_string = mime::AppendParameter(mime::text::kXml,
- mime::parameters::kCharset,
- "utf-8");
+ std::string mime_string = mime::AppendParameter(
+ mime::text::kXml, mime::parameters::kCharset, "utf-8");
EXPECT_EQ("text/xml; charset=utf-8", mime_string);
mime_string = mime::AppendParameter(mime_string, "foo", "bar");
EXPECT_EQ("text/xml; charset=utf-8; foo=bar", mime_string);
- EXPECT_EQ("utf-8", mime::GetParameterValue(mime_string,
- mime::parameters::kCharset));
+ EXPECT_EQ("utf-8",
+ mime::GetParameterValue(mime_string, mime::parameters::kCharset));
EXPECT_EQ("bar", mime::GetParameterValue(mime_string, "foo"));
EXPECT_EQ("", mime::GetParameterValue(mime_string, "baz"));
mime_string = mime::RemoveParameters(mime_string);
diff --git a/chromeos/osrelease_reader.cc b/chromeos/osrelease_reader.cc
index 92a86f3..15f5065 100644
--- a/chromeos/osrelease_reader.cc
+++ b/chromeos/osrelease_reader.cc
@@ -34,9 +34,8 @@
}
base::FilePath osreleased = root_dir.Append("etc").Append("os-release.d");
- base::FileEnumerator enumerator(osreleased,
- false,
- base::FileEnumerator::FILES);
+ base::FileEnumerator enumerator(
+ osreleased, false, base::FileEnumerator::FILES);
for (base::FilePath path = enumerator.Next(); !path.empty();
path = enumerator.Next()) {
diff --git a/chromeos/osrelease_reader_unittest.cc b/chromeos/osrelease_reader_unittest.cc
index a7f99da..ea5ec75 100644
--- a/chromeos/osrelease_reader_unittest.cc
+++ b/chromeos/osrelease_reader_unittest.cc
@@ -77,9 +77,8 @@
string bonjour = "bonjour\ngarbage";
base::WriteFile(osreleased_.Append("HELLO"), hello.data(), hello.size());
- base::WriteFile(osreleased_.Append("BONJOUR"),
- bonjour.data(),
- bonjour.size());
+ base::WriteFile(
+ osreleased_.Append("BONJOUR"), bonjour.data(), bonjour.size());
store_.LoadTestingOnly(temp_dir_.path());
diff --git a/chromeos/process.cc b/chromeos/process.cc
index 4376f5e..6e2a2a4 100644
--- a/chromeos/process.cc
+++ b/chromeos/process.cc
@@ -23,7 +23,9 @@
namespace chromeos {
-bool ReturnTrue() { return true; }
+bool ReturnTrue() {
+ return true;
+}
Process::Process() {
}
@@ -36,10 +38,13 @@
base::FilePath(base::StringPrintf("/proc/%d", pid)));
}
-ProcessImpl::ProcessImpl() : pid_(0), uid_(-1), gid_(-1),
- pre_exec_(base::Bind(&ReturnTrue)),
- search_path_(false),
- inherit_parent_signal_mask_(false) {
+ProcessImpl::ProcessImpl()
+ : pid_(0),
+ uid_(-1),
+ gid_(-1),
+ pre_exec_(base::Bind(&ReturnTrue)),
+ search_path_(false),
+ inherit_parent_signal_mask_(false) {
}
ProcessImpl::~ProcessImpl() {
@@ -175,13 +180,12 @@
IGNORE_EINTR(close(i->second.child_fd_));
}
if (!output_file_.empty()) {
- int output_handle = HANDLE_EINTR(
- open(output_file_.c_str(),
- O_CREAT | O_WRONLY | O_TRUNC | O_EXCL, 0666));
+ int output_handle = HANDLE_EINTR(open(
+ output_file_.c_str(), O_CREAT | O_WRONLY | O_TRUNC | O_EXCL, 0666));
int saved_errno = errno;
if (output_handle < 0) {
- LOG(ERROR) << "Could not create " << output_file_
- << ": " << saved_errno;
+ LOG(ERROR) << "Could not create " << output_file_ << ": "
+ << saved_errno;
// Avoid exit() to avoid atexit handlers from parent.
_exit(kErrorExitStatus);
}
@@ -252,8 +256,8 @@
if (!WIFEXITED(status)) {
DCHECK(WIFSIGNALED(status)) << old_pid
<< " neither exited, nor died on a signal?";
- LOG(ERROR) << "Process " << old_pid << " did not exit normally: "
- << WTERMSIG(status);
+ LOG(ERROR) << "Process " << old_pid
+ << " did not exit normally: " << WTERMSIG(status);
return -1;
}
return WEXITSTATUS(status);
diff --git a/chromeos/process_information.cc b/chromeos/process_information.cc
index 6d3a7f8..9f1d773 100644
--- a/chromeos/process_information.cc
+++ b/chromeos/process_information.cc
@@ -6,9 +6,10 @@
namespace chromeos {
-ProcessInformation::ProcessInformation()
- : cmd_line_(), process_id_(-1) { }
-ProcessInformation::~ProcessInformation() { }
+ProcessInformation::ProcessInformation() : cmd_line_(), process_id_(-1) {
+}
+ProcessInformation::~ProcessInformation() {
+}
std::string ProcessInformation::GetCommandLine() {
std::string result;
diff --git a/chromeos/process_information.h b/chromeos/process_information.h
index 08b5742..bc2818e 100644
--- a/chromeos/process_information.h
+++ b/chromeos/process_information.h
@@ -29,9 +29,7 @@
cmd_line_.swap(*value);
}
- const std::vector<std::string>& get_cmd_line() {
- return cmd_line_;
- }
+ const std::vector<std::string>& get_cmd_line() { return cmd_line_; }
// Set the command line array. This method DOES swap out the contents of
// |value|. The caller should expect an empty set on return.
@@ -40,9 +38,7 @@
open_files_.swap(*value);
}
- const std::set<std::string>& get_open_files() {
- return open_files_;
- }
+ const std::set<std::string>& get_open_files() { return open_files_; }
// Set the command line array. This method DOES swap out the contents of
// |value|. The caller should expect an empty string on return.
@@ -51,17 +47,11 @@
cwd_.swap(*value);
}
- const std::string& get_cwd() {
- return cwd_;
- }
+ const std::string& get_cwd() { return cwd_; }
- void set_process_id(int value) {
- process_id_ = value;
- }
+ void set_process_id(int value) { process_id_ = value; }
- int get_process_id() {
- return process_id_;
- }
+ int get_process_id() { return process_id_; }
private:
std::vector<std::string> cmd_line_;
diff --git a/chromeos/process_test.cc b/chromeos/process_test.cc
index 7ad51fa..eeaf14f 100644
--- a/chromeos/process_test.cc
+++ b/chromeos/process_test.cc
@@ -57,7 +57,7 @@
TEST(SimpleProcess, BindFd) {
int fds[2];
char buf[16];
- static const char *kMsg = "hello, world!";
+ static const char* kMsg = "hello, world!";
ProcessImpl process;
EXPECT_EQ(0, pipe(fds));
process.AddArg(kBinEcho);
@@ -80,9 +80,7 @@
ClearLog();
}
- void TearDown() {
- base::DeleteFile(test_path_, true);
- }
+ void TearDown() { base::DeleteFile(test_path_, true); }
protected:
void CheckStderrCaptured();
@@ -247,8 +245,7 @@
EXPECT_EQ(static_cast<pid_t>(Process::kErrorExitStatus), process_.Run());
std::string contents;
EXPECT_TRUE(base::ReadFileToString(FilePath(output_file_), &contents));
- EXPECT_NE(std::string::npos,
- contents.find("Unable to set UID to 0: 1\n"));
+ EXPECT_NE(std::string::npos, contents.find("Unable to set UID to 0: 1\n"));
}
TEST_F(ProcessTest, WithIllegalGid) {
@@ -258,8 +255,7 @@
EXPECT_EQ(static_cast<pid_t>(Process::kErrorExitStatus), process_.Run());
std::string contents;
EXPECT_TRUE(base::ReadFileToString(FilePath(output_file_), &contents));
- EXPECT_NE(std::string::npos,
- contents.find("Unable to set GID to 0: 1\n"));
+ EXPECT_NE(std::string::npos, contents.find("Unable to set GID to 0: 1\n"));
}
TEST_F(ProcessTest, NoParams) {
diff --git a/chromeos/secure_blob.cc b/chromeos/secure_blob.cc
index 857b612..1ef950b 100644
--- a/chromeos/secure_blob.cc
+++ b/chromeos/secure_blob.cc
@@ -10,16 +10,14 @@
namespace chromeos {
-SecureBlob::SecureBlob()
- : chromeos::Blob() {
+SecureBlob::SecureBlob() : chromeos::Blob() {
}
SecureBlob::SecureBlob(const_iterator begin, const_iterator end)
: chromeos::Blob(begin, end) {
}
-SecureBlob::SecureBlob(size_t size)
- : chromeos::Blob(size) {
+SecureBlob::SecureBlob(size_t size) : chromeos::Blob(size) {
}
SecureBlob::SecureBlob(const std::string& from)
diff --git a/chromeos/secure_blob.h b/chromeos/secure_blob.h
index a9e3b8c..8bdc9da 100644
--- a/chromeos/secure_blob.h
+++ b/chromeos/secure_blob.h
@@ -35,8 +35,7 @@
const void* const_data() const;
std::string to_string() const;
- static SecureBlob Combine(const SecureBlob& blob1,
- const SecureBlob& blob2);
+ static SecureBlob Combine(const SecureBlob& blob1, const SecureBlob& blob2);
};
// Secure memset(). This function is guaranteed to fill int the whole buffer
diff --git a/chromeos/secure_blob_unittest.cc b/chromeos/secure_blob_unittest.cc
index 857a5bb..409613f 100644
--- a/chromeos/secure_blob_unittest.cc
+++ b/chromeos/secure_blob_unittest.cc
@@ -18,20 +18,20 @@
class SecureBlobTest : public ::testing::Test {
public:
- SecureBlobTest() { }
- virtual ~SecureBlobTest() { }
+ SecureBlobTest() {}
+ virtual ~SecureBlobTest() {}
static bool FindBlobInBlob(const chromeos::Blob& haystack,
const chromeos::Blob& needle) {
- auto pos = std::search(haystack.begin(), haystack.end(), needle.begin(),
- needle.end());
+ auto pos = std::search(
+ haystack.begin(), haystack.end(), needle.begin(), needle.end());
return (pos != haystack.end());
}
static int FindBlobIndexInBlob(const chromeos::Blob& haystack,
const chromeos::Blob& needle) {
- auto pos = std::search(haystack.begin(), haystack.end(), needle.begin(),
- needle.end());
+ auto pos = std::search(
+ haystack.begin(), haystack.end(), needle.begin(), needle.end());
if (pos == haystack.end()) {
return -1;
}
diff --git a/chromeos/strings/string_utils.cc b/chromeos/strings/string_utils.cc
index 0e71891..10a7d57 100644
--- a/chromeos/strings/string_utils.cc
+++ b/chromeos/strings/string_utils.cc
@@ -36,9 +36,9 @@
}
if (trim_whitespaces) {
- std::for_each(tokens.begin(), tokens.end(),
- [](std::string& str) {
- base::TrimWhitespaceASCII(str, base::TRIM_ALL, &str); });
+ std::for_each(tokens.begin(), tokens.end(), [](std::string& str) {
+ base::TrimWhitespaceASCII(str, base::TRIM_ALL, &str);
+ });
if (purge_empty_strings) {
// We might have removed all the characters from a string if they were
// all whitespaces. If we don't want empty strings, make sure we remove
@@ -99,12 +99,14 @@
}
std::string Join(char delimiter,
- const std::string& str1, const std::string& str2) {
+ const std::string& str1,
+ const std::string& str2) {
return str1 + delimiter + str2;
}
std::string Join(const std::string& delimiter,
- const std::string& str1, const std::string& str2) {
+ const std::string& str1,
+ const std::string& str2) {
return str1 + delimiter + str2;
}
diff --git a/chromeos/strings/string_utils.h b/chromeos/strings/string_utils.h
index ff3113e..9535cd8 100644
--- a/chromeos/strings/string_utils.h
+++ b/chromeos/strings/string_utils.h
@@ -19,11 +19,10 @@
// |trim_whitespaces| causes each element to have all whitespaces trimmed off.
// |purge_empty_strings| specifies whether empty elements from the original
// string should be omitted.
-CHROMEOS_EXPORT std::vector<std::string> Split(
- const std::string& str,
- char delimiter,
- bool trim_whitespaces,
- bool purge_empty_strings);
+CHROMEOS_EXPORT std::vector<std::string> Split(const std::string& str,
+ char delimiter,
+ bool trim_whitespaces,
+ bool purge_empty_strings);
// Splits the string, trims all whitespaces, omits empty string parts.
inline std::vector<std::string> Split(const std::string& str, char delimiter) {
return Split(str, delimiter, true, true);
@@ -37,15 +36,12 @@
// Splits the string into two pieces at the first position of the specified
// delimiter.
-CHROMEOS_EXPORT std::pair<std::string, std::string> SplitAtFirst(
- const std::string& str,
- char delimiter,
- bool trim_whitespaces);
+CHROMEOS_EXPORT std::pair<std::string, std::string>
+SplitAtFirst(const std::string& str, char delimiter, bool trim_whitespaces);
// Splits the string into two pieces at the first position of the specified
// delimiter. Both parts have all whitespaces trimmed off.
-inline std::pair<std::string, std::string> SplitAtFirst(
- const std::string& str,
- char delimiter) {
+inline std::pair<std::string, std::string> SplitAtFirst(const std::string& str,
+ char delimiter) {
return SplitAtFirst(str, delimiter, true);
}
@@ -81,10 +77,14 @@
// to a string. In most cases, it redirects the call to std::to_string with
// two exceptions: for std::string itself and for double and bool.
template<typename T>
-inline std::string ToString(T value) { return std::to_string(value); }
+inline std::string ToString(T value) {
+ return std::to_string(value);
+}
// Having the following overload is handy for templates where the type
// of template parameter isn't known and could be a string itself.
-inline std::string ToString(std::string value) { return value; }
+inline std::string ToString(std::string value) {
+ return value;
+}
// We overload this for double because std::to_string(double) uses %f to
// format the value and I would like to use a shorter %g format instead.
CHROMEOS_EXPORT std::string ToString(double value);
diff --git a/chromeos/syslog_logging.cc b/chromeos/syslog_logging.cc
index 1c54b6c..79d0840 100644
--- a/chromeos/syslog_logging.cc
+++ b/chromeos/syslog_logging.cc
@@ -37,7 +37,7 @@
const char* file,
int line,
size_t message_start,
- const std::string &message) {
+ const std::string& message) {
switch (severity) {
case logging::LOG_INFO:
severity = kSyslogInfo;
@@ -60,7 +60,7 @@
break;
}
- const char *str;
+ const char* str;
if (s_log_header) {
str = message.c_str();
} else {
@@ -82,9 +82,9 @@
}
int GetLogFlags() {
int flags = 0;
- flags |= (s_log_to_syslog) ?kLogToSyslog :0;
- flags |= (s_log_to_stderr) ?kLogToStderr :0;
- flags |= (s_log_header) ?kLogHeader :0;
+ flags |= (s_log_to_syslog) ? kLogToSyslog : 0;
+ flags |= (s_log_to_stderr) ? kLogToStderr : 0;
+ flags |= (s_log_header) ? kLogHeader : 0;
return flags;
}
void InitLog(int init_flags) {
@@ -96,8 +96,8 @@
const bool kOptionTID = false;
const bool kOptionTimestamp = false;
const bool kOptionTickcount = false;
- logging::SetLogItems(kOptionPID, kOptionTID, kOptionTimestamp,
- kOptionTickcount);
+ logging::SetLogItems(
+ kOptionPID, kOptionTID, kOptionTimestamp, kOptionTickcount);
logging::SetLogMessageHandler(HandleMessage);
SetLogFlags(init_flags);
}
diff --git a/chromeos/syslog_logging_unittest.cc b/chromeos/syslog_logging_unittest.cc
index cb11119..982b83a 100644
--- a/chromeos/syslog_logging_unittest.cc
+++ b/chromeos/syslog_logging_unittest.cc
@@ -10,8 +10,8 @@
class SyslogLoggingDeathTest : public ::testing::Test {
public:
- SyslogLoggingDeathTest() { }
- virtual ~SyslogLoggingDeathTest() { }
+ SyslogLoggingDeathTest() {}
+ virtual ~SyslogLoggingDeathTest() {}
private:
DISALLOW_COPY_AND_ASSIGN(SyslogLoggingDeathTest);
@@ -20,13 +20,11 @@
TEST_F(SyslogLoggingDeathTest, FatalLoggingIsFatal) {
int old_flags = GetLogFlags();
SetLogFlags(kLogToStderr);
- EXPECT_DEATH({ LOG(FATAL) << "First Fatality!"; },
- "First Fatality!");
+ EXPECT_DEATH({ LOG(FATAL) << "First Fatality!"; }, "First Fatality!");
// No flags == don't log to syslog, stderr, or accumulated string.
SetLogFlags(0);
// Still a fatal log message
- EXPECT_DEATH({ LOG(FATAL) << "Second Fatality!"; },
- "Second Fatality!");
+ EXPECT_DEATH({ LOG(FATAL) << "Second Fatality!"; }, "Second Fatality!");
SetLogFlags(old_flags);
}
diff --git a/chromeos/test_helpers.h b/chromeos/test_helpers.h
index 89ffd3d..bfefe77 100644
--- a/chromeos/test_helpers.h
+++ b/chromeos/test_helpers.h
@@ -16,14 +16,13 @@
#include "chromeos/syslog_logging.h"
-inline void ExpectFileEquals(const char* golden,
- const char* file_path) {
+inline void ExpectFileEquals(const char* golden, const char* file_path) {
std::string contents;
EXPECT_TRUE(base::ReadFileToString(base::FilePath(file_path), &contents));
EXPECT_EQ(golden, contents);
}
-inline void SetUpTests(int *argc, char** argv, bool log_to_stderr) {
+inline void SetUpTests(int* argc, char** argv, bool log_to_stderr) {
CommandLine::Init(*argc, argv);
::chromeos::InitLog(log_to_stderr ? chromeos::kLogToStderr : 0);
::chromeos::LogToString(true);
diff --git a/chromeos/url_utils.cc b/chromeos/url_utils.cc
index 07cbc9a..3a2e166 100644
--- a/chromeos/url_utils.cc
+++ b/chromeos/url_utils.cc
@@ -21,8 +21,10 @@
// If |exclude_fragment| is true, the function returns the start character and
// the length of the query string alone. If it is false, the query string length
// will include both the query string and the fragment.
-bool GetQueryStringPos(const std::string& url, bool exclude_fragment,
- size_t* query_pos, size_t* query_len) {
+bool GetQueryStringPos(const std::string& url,
+ bool exclude_fragment,
+ size_t* query_pos,
+ size_t* query_len) {
size_t query_start = url.find_first_of("?#");
if (query_start == std::string::npos) {
*query_pos = url.size();
@@ -61,13 +63,12 @@
return query_string;
}
-std::string url::Combine(
- const std::string& url, const std::string& subpath) {
+std::string url::Combine(const std::string& url, const std::string& subpath) {
return CombineMultiple(url, {subpath});
}
-std::string url::CombineMultiple(
- const std::string& url, const std::vector<std::string>& parts) {
+std::string url::CombineMultiple(const std::string& url,
+ const std::vector<std::string>& parts) {
std::string result = url;
if (!parts.empty()) {
std::string query_string = TrimOffQueryString(&result);
@@ -85,8 +86,7 @@
return result;
}
-std::string url::GetQueryString(
- const std::string& url, bool remove_fragment) {
+std::string url::GetQueryString(const std::string& url, bool remove_fragment) {
std::string query_string;
size_t query_pos, query_len;
if (GetQueryStringPos(url, remove_fragment, &query_pos, &query_len)) {
@@ -104,8 +104,8 @@
return data_encoding::WebParamsDecode(query_string);
}
-std::string url::GetQueryStringValue(
- const std::string& url, const std::string& name) {
+std::string url::GetQueryStringValue(const std::string& url,
+ const std::string& name) {
return GetQueryStringValue(GetQueryStringParameters(url), name);
}
@@ -118,8 +118,8 @@
return std::string();
}
-std::string url::RemoveQueryString(
- const std::string& url, bool remove_fragment_too) {
+std::string url::RemoveQueryString(const std::string& url,
+ bool remove_fragment_too) {
size_t query_pos, query_len;
if (!GetQueryStringPos(url, !remove_fragment_too, &query_pos, &query_len))
return url;
@@ -131,8 +131,9 @@
return result;
}
-std::string url::AppendQueryParam(
- const std::string& url, const std::string& name, const std::string& value) {
+std::string url::AppendQueryParam(const std::string& url,
+ const std::string& name,
+ const std::string& value) {
return AppendQueryParams(url, {{name, value}});
}
diff --git a/chromeos/url_utils_unittest.cc b/chromeos/url_utils_unittest.cc
index 6c16e2c..d52d720 100644
--- a/chromeos/url_utils_unittest.cc
+++ b/chromeos/url_utils_unittest.cc
@@ -15,14 +15,12 @@
url::Combine("http://sample.org/", "path"));
EXPECT_EQ("path1/path2", url::Combine("", "path1/path2"));
EXPECT_EQ("path1/path2", url::Combine("path1", "path2"));
- EXPECT_EQ("http://sample.org",
- url::Combine("http://sample.org", ""));
+ EXPECT_EQ("http://sample.org", url::Combine("http://sample.org", ""));
EXPECT_EQ("http://sample.org/path",
url::Combine("http://sample.org/", "/path"));
EXPECT_EQ("http://sample.org/path",
url::Combine("http://sample.org", "//////path"));
- EXPECT_EQ("http://sample.org/",
- url::Combine("http://sample.org", "///"));
+ EXPECT_EQ("http://sample.org/", url::Combine("http://sample.org", "///"));
EXPECT_EQ("http://sample.org/obj/path1/path2",
url::Combine("http://sample.org/obj", "path1/path2"));
EXPECT_EQ("http://sample.org/obj/path1/path2#tag",
@@ -50,25 +48,19 @@
EXPECT_EQ("?q=v&b=2",
url::GetQueryString("http://s.com/?q=v&b=2#tag?2", true));
- EXPECT_EQ("#tag?a=2",
- url::GetQueryString("http://s.com/#tag?a=2", false));
- EXPECT_EQ("",
- url::GetQueryString("http://s.com/#tag?a=2", true));
+ EXPECT_EQ("#tag?a=2", url::GetQueryString("http://s.com/#tag?a=2", false));
+ EXPECT_EQ("", url::GetQueryString("http://s.com/#tag?a=2", true));
- EXPECT_EQ("?a=2&b=2",
- url::GetQueryString("?a=2&b=2", false));
- EXPECT_EQ("?a=2&b=2",
- url::GetQueryString("?a=2&b=2", true));
+ EXPECT_EQ("?a=2&b=2", url::GetQueryString("?a=2&b=2", false));
+ EXPECT_EQ("?a=2&b=2", url::GetQueryString("?a=2&b=2", true));
- EXPECT_EQ("#s#?d#?f?#s?#d",
- url::GetQueryString("#s#?d#?f?#s?#d", false));
- EXPECT_EQ("",
- url::GetQueryString("#s#?d#?f?#s?#d", true));
+ EXPECT_EQ("#s#?d#?f?#s?#d", url::GetQueryString("#s#?d#?f?#s?#d", false));
+ EXPECT_EQ("", url::GetQueryString("#s#?d#?f?#s?#d", true));
}
TEST(UrlUtils, GetQueryStringParameters) {
auto params = url::GetQueryStringParameters(
- "http://sample.org/path?k=v&&%3Dkey%3D=val%26&r#blah");
+ "http://sample.org/path?k=v&&%3Dkey%3D=val%26&r#blah");
EXPECT_EQ(3, params.size());
EXPECT_EQ("k", params[0].first);