shill: net: fix cpp style
Stop using "using" with std:: and base:: in shill/net.
Also fix redundant imports.
BUG=None
TEST=unit tests
Change-Id: I33af7a8a79e0290387109b30c26fb404db4c92a1
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform2/+/2831671
Tested-by: Hugo Benichi <hugobenichi@google.com>
Commit-Queue: Hugo Benichi <hugobenichi@google.com>
Reviewed-by: Steven Bennetts <stevenjb@chromium.org>
Reviewed-by: Eric Caruso <ejcaruso@chromium.org>
diff --git a/shill/net/attribute_list.cc b/shill/net/attribute_list.cc
index 4861f43..c66fb27 100644
--- a/shill/net/attribute_list.cc
+++ b/shill/net/attribute_list.cc
@@ -8,17 +8,12 @@
#include <linux/nl80211.h>
#include <iomanip>
-#include <memory>
-#include <string>
#include <base/logging.h>
#include <base/stl_util.h>
#include "shill/logging.h"
#include "shill/net/netlink_attribute.h"
-#include "shill/net/netlink_message.h"
-
-using std::string;
namespace shill {
@@ -265,7 +260,7 @@
// String Attribute.
-bool AttributeList::GetStringAttributeValue(int id, string* value) const {
+bool AttributeList::GetStringAttributeValue(int id, std::string* value) const {
NetlinkAttribute* attribute = GetAttribute(id);
if (!attribute)
return false;
@@ -290,7 +285,7 @@
return true;
}
-bool AttributeList::SetStringAttributeValue(int id, const string& value) {
+bool AttributeList::SetStringAttributeValue(int id, const std::string& value) {
NetlinkAttribute* attribute = GetAttribute(id);
if (!attribute)
return false;
diff --git a/shill/net/byte_string.cc b/shill/net/byte_string.cc
index c08e241..ae6b93e 100644
--- a/shill/net/byte_string.cc
+++ b/shill/net/byte_string.cc
@@ -5,16 +5,11 @@
#include "shill/net/byte_string.h"
#include <netinet/in.h>
-#include <string.h>
#include <algorithm>
#include <base/strings/string_number_conversions.h>
-using std::min;
-using std::string;
-using std::vector;
-
namespace shill {
unsigned char* ByteString::GetData() {
@@ -54,8 +49,8 @@
}
// static
-ByteString ByteString::CreateFromHexString(const string& hex_string) {
- vector<uint8_t> bytes;
+ByteString ByteString::CreateFromHexString(const std::string& hex_string) {
+ std::vector<uint8_t> bytes;
if (!base::HexStringToBytes(hex_string, &bytes)) {
return ByteString();
}
@@ -165,7 +160,7 @@
data_.resize(size, 0);
}
-string ByteString::HexEncode() const {
+std::string ByteString::HexEncode() const {
return base::HexEncode(GetConstData(), GetLength());
}
@@ -179,7 +174,7 @@
// static
bool ByteString::IsLessThan(const ByteString& lhs, const ByteString& rhs) {
- size_t byte_count = min(lhs.GetLength(), rhs.GetLength());
+ size_t byte_count = std::min(lhs.GetLength(), rhs.GetLength());
int result = memcmp(lhs.GetConstData(), rhs.GetConstData(), byte_count);
if (result == 0) {
return lhs.GetLength() < rhs.GetLength();
diff --git a/shill/net/byte_string_test.cc b/shill/net/byte_string_test.cc
index 5933f35..a6fe2bc 100644
--- a/shill/net/byte_string_test.cc
+++ b/shill/net/byte_string_test.cc
@@ -12,7 +12,6 @@
#include <gtest/gtest.h>
-using std::string;
using testing::Test;
namespace shill {
@@ -93,11 +92,11 @@
}
TEST_F(ByteStringTest, CopyTerminator) {
- ByteString bs4(string(kTest4), false);
+ ByteString bs4(std::string(kTest4), false);
EXPECT_EQ(strlen(kTest4), bs4.GetLength());
EXPECT_EQ(0, memcmp(kTest4, bs4.GetData(), bs4.GetLength()));
- ByteString bs5(string(kTest4), true);
+ ByteString bs5(std::string(kTest4), true);
EXPECT_EQ(strlen(kTest4) + 1, bs5.GetLength());
EXPECT_EQ(0, memcmp(kTest4, bs5.GetData(), bs5.GetLength()));
}
diff --git a/shill/net/event_history.cc b/shill/net/event_history.cc
index 8696090..7503742 100644
--- a/shill/net/event_history.cc
+++ b/shill/net/event_history.cc
@@ -6,15 +6,9 @@
#include <time.h>
-#include <deque>
-
#include <base/logging.h>
#include <base/notreached.h>
-#include "shill/net/shill_time.h"
-
-using std::deque;
-
namespace shill {
void EventHistory::RecordEvent() {
@@ -34,7 +28,7 @@
std::vector<std::string> EventHistory::ExtractWallClockToStrings() const {
std::vector<std::string> strings;
- for (deque<Timestamp>::const_iterator it = events_.begin();
+ for (std::deque<Timestamp>::const_iterator it = events_.begin();
it != events_.end(); ++it) {
strings.push_back(it->wall_clock);
}
diff --git a/shill/net/event_history_test.cc b/shill/net/event_history_test.cc
index 7a77f47..46b4a25 100644
--- a/shill/net/event_history_test.cc
+++ b/shill/net/event_history_test.cc
@@ -4,6 +4,7 @@
#include "shill/net/event_history.h"
+#include <deque>
#include <memory>
#include <string>
#include <vector>
@@ -14,9 +15,6 @@
#include "shill/net/mock_time.h"
#include "shill/net/shill_time.h"
-using std::deque;
-using std::string;
-using std::vector;
using ::testing::Return;
namespace shill {
@@ -47,7 +45,7 @@
bool GetMaxEventsSpecified() { return event_history_->max_events_specified_; }
- deque<Timestamp>* GetEvents() { return &event_history_->events_; }
+ std::deque<Timestamp>* GetEvents() { return &event_history_->events_; }
void RecordEvent(Timestamp now) {
EXPECT_CALL(time_, GetNow()).WillOnce(Return(now));
@@ -68,13 +66,13 @@
event_history_->RecordEventAndExpireEventsBefore(seconds_ago, clock_type);
}
- vector<string> ExtractWallClockToStrings() {
+ std::vector<std::string> ExtractWallClockToStrings() {
return event_history_->ExtractWallClockToStrings();
}
Timestamp GetTimestamp(int monotonic_seconds,
int boottime_seconds,
- const string& wall_clock) {
+ const std::string& wall_clock) {
struct timeval monotonic = {.tv_sec = monotonic_seconds, .tv_usec = 0};
struct timeval boottime = {.tv_sec = boottime_seconds, .tv_usec = 0};
return Timestamp(monotonic, boottime, wall_clock);
@@ -233,7 +231,7 @@
RecordEvent(kValues[i]);
}
- vector<string> strings = ExtractWallClockToStrings();
+ std::vector<std::string> strings = ExtractWallClockToStrings();
EXPECT_GT(base::size(kValues), 0);
ASSERT_EQ(base::size(kValues), strings.size());
for (size_t i = 0; i < base::size(kValues); i++) {
diff --git a/shill/net/generic_netlink_message.cc b/shill/net/generic_netlink_message.cc
index d03ca0f..d6933e7 100644
--- a/shill/net/generic_netlink_message.cc
+++ b/shill/net/generic_netlink_message.cc
@@ -4,7 +4,6 @@
#include "shill/net/generic_netlink_message.h"
-#include <memory>
#include <string>
#include <base/bind.h>
@@ -15,9 +14,6 @@
#include "shill/net/netlink_attribute.h"
#include "shill/net/netlink_packet.h"
-using base::Bind;
-using base::StringPrintf;
-
namespace shill {
namespace Logging {
@@ -96,7 +92,7 @@
void GenericNetlinkMessage::Print(int header_log_level,
int detail_log_level) const {
SLOG(this, header_log_level)
- << StringPrintf("Message %s (%d)", command_string(), command());
+ << base::StringPrintf("Message %s (%d)", command_string(), command());
attributes_->Print(detail_log_level, 1);
}
@@ -116,7 +112,7 @@
}
return packet->ConsumeAttributes(
- Bind(&NetlinkAttribute::NewControlAttributeFromId), attributes_);
+ base::Bind(&NetlinkAttribute::NewControlAttributeFromId), attributes_);
}
// Specific Control types.
diff --git a/shill/net/ip_address.cc b/shill/net/ip_address.cc
index bc16895..d0605fe 100644
--- a/shill/net/ip_address.cc
+++ b/shill/net/ip_address.cc
@@ -5,11 +5,8 @@
#include "shill/net/ip_address.h"
#include <arpa/inet.h>
-#include <netinet/in.h>
#include <limits>
-#include <string>
-#include <vector>
#include <base/check.h>
#include <base/check_op.h>
@@ -18,11 +15,6 @@
#include <base/strings/string_number_conversions.h>
#include <base/strings/string_split.h>
-#include "shill/net/byte_string.h"
-
-using std::string;
-using std::vector;
-
namespace shill {
namespace {
@@ -121,7 +113,8 @@
}
// static
-size_t IPAddress::GetPrefixLengthFromMask(Family family, const string& mask) {
+size_t IPAddress::GetPrefixLengthFromMask(Family family,
+ const std::string& mask) {
switch (family) {
case kFamilyIPv4: {
in_addr_t mask_val = inet_network(mask.c_str());
@@ -166,7 +159,7 @@
}
// static
-string IPAddress::GetAddressFamilyName(Family family) {
+std::string IPAddress::GetAddressFamilyName(Family family) {
switch (family) {
case kFamilyIPv4:
return kFamilyNameIPv4;
@@ -177,7 +170,7 @@
}
}
-bool IPAddress::SetAddressFromString(const string& address_string) {
+bool IPAddress::SetAddressFromString(const std::string& address_string) {
size_t address_length = GetAddressLength(family_);
if (!address_length) {
@@ -192,8 +185,9 @@
return true;
}
-bool IPAddress::SetAddressAndPrefixFromString(const string& address_string) {
- vector<string> address_parts = base::SplitString(
+bool IPAddress::SetAddressAndPrefixFromString(
+ const std::string& address_string) {
+ const auto address_parts = base::SplitString(
address_string, "/", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
if (address_parts.size() != 2) {
LOG(ERROR) << "Cannot split address " << address_string;
@@ -217,7 +211,7 @@
address_ = ByteString(GetAddressLength(family_));
}
-bool IPAddress::IntoString(string* address_string) const {
+bool IPAddress::IntoString(std::string* address_string) const {
// Noting that INET6_ADDRSTRLEN > INET_ADDRSTRLEN
char address_buf[INET6_ADDRSTRLEN];
if (GetLength() != GetAddressLength(family_) ||
@@ -228,8 +222,8 @@
return true;
}
-string IPAddress::ToString() const {
- string out("<unknown>");
+std::string IPAddress::ToString() const {
+ std::string out = "<unknown>";
IntoString(&out);
return out;
}
diff --git a/shill/net/ip_address_test.cc b/shill/net/ip_address_test.cc
index 3a86d9c..86ad998 100644
--- a/shill/net/ip_address_test.cc
+++ b/shill/net/ip_address_test.cc
@@ -15,7 +15,6 @@
#include "shill/net/byte_string.h"
#include "shill/net/ip_address.h"
-using std::string;
using testing::Test;
namespace shill {
@@ -37,9 +36,9 @@
class IPAddressTest : public Test {
protected:
void TestAddress(IPAddress::Family family,
- const string& good_string,
+ const std::string& good_string,
const ByteString& good_bytes,
- const string& bad_string,
+ const std::string& bad_string,
const ByteString& bad_bytes) {
IPAddress good_addr(family);
@@ -50,7 +49,7 @@
EXPECT_EQ(0, memcmp(good_addr.GetConstData(), good_bytes.GetConstData(),
good_bytes.GetLength()));
EXPECT_TRUE(good_addr.address().Equals(good_bytes));
- string address_string;
+ std::string address_string;
EXPECT_TRUE(good_addr.IntoString(&address_string));
EXPECT_EQ(good_string, address_string);
@@ -158,8 +157,8 @@
TEST_F(IPAddressTest, SetAddressAndPrefixFromString) {
IPAddress address(IPAddress::kFamilyIPv4);
- const string kString1(kV4String1);
- const string kString2(kV4String2);
+ const std::string kString1(kV4String1);
+ const std::string kString2(kV4String2);
EXPECT_FALSE(address.SetAddressAndPrefixFromString(""));
EXPECT_FALSE(address.SetAddressAndPrefixFromString(kString1));
EXPECT_FALSE(address.SetAddressAndPrefixFromString(kString1 + "/"));
@@ -178,7 +177,7 @@
}
TEST_F(IPAddressTest, HasSameAddressAs) {
- const string kString1(kV4String1);
+ const std::string kString1(kV4String1);
IPAddress address0(IPAddress::kFamilyIPv4);
EXPECT_TRUE(address0.SetAddressAndPrefixFromString(kString1 + "/0"));
IPAddress address1(IPAddress::kFamilyIPv4);
@@ -196,13 +195,13 @@
PrefixMapping() : family(IPAddress::kFamilyUnknown), prefix(0) {}
PrefixMapping(IPAddress::Family family_in,
size_t prefix_in,
- const string& expected_address_in)
+ const std::string& expected_address_in)
: family(family_in),
prefix(prefix_in),
expected_address(expected_address_in) {}
IPAddress::Family family;
size_t prefix;
- string expected_address;
+ std::string expected_address;
};
class IPAddressPrefixMappingTest
@@ -261,20 +260,20 @@
struct BitOperationMapping {
BitOperationMapping() : family(IPAddress::kFamilyUnknown) {}
BitOperationMapping(IPAddress::Family family_in,
- const string& address_a_in,
- const string& address_b_in,
- const string& expected_anded_in,
- const string& expected_orred_in)
+ const std::string& address_a_in,
+ const std::string& address_b_in,
+ const std::string& expected_anded_in,
+ const std::string& expected_orred_in)
: family(family_in),
address_a(address_a_in),
address_b(address_b_in),
expected_anded(expected_anded_in),
expected_orred(expected_orred_in) {}
IPAddress::Family family;
- string address_a;
- string address_b;
- string expected_anded;
- string expected_orred;
+ std::string address_a;
+ std::string address_b;
+ std::string expected_anded;
+ std::string expected_orred;
};
class IPAddressBitOperationMappingTest
@@ -330,20 +329,20 @@
struct NetworkPartMapping {
NetworkPartMapping() : family(IPAddress::kFamilyUnknown) {}
NetworkPartMapping(IPAddress::Family family_in,
- const string& address_in,
+ const std::string& address_in,
size_t prefix_in,
- const string& expected_network_in,
- const string& expected_broadcast_in)
+ const std::string& expected_network_in,
+ const std::string& expected_broadcast_in)
: family(family_in),
address(address_in),
prefix(prefix_in),
expected_network(expected_network_in),
expected_broadcast(expected_broadcast_in) {}
IPAddress::Family family;
- string address;
+ std::string address;
size_t prefix;
- string expected_network;
- string expected_broadcast;
+ std::string expected_network;
+ std::string expected_broadcast;
};
class IPAddressNetworkPartMappingTest
@@ -410,13 +409,13 @@
struct MinPrefixLengthMapping {
MinPrefixLengthMapping() : family(IPAddress::kFamilyUnknown) {}
MinPrefixLengthMapping(IPAddress::Family family_in,
- const string& address_in,
+ const std::string& address_in,
size_t expected_min_prefix_in)
: family(family_in),
address(address_in),
expected_min_prefix(expected_min_prefix_in) {}
IPAddress::Family family;
- string address;
+ std::string address;
size_t expected_min_prefix;
};
@@ -441,9 +440,9 @@
MinPrefixLengthMapping(IPAddress::kFamilyIPv4, "10.10.10.10", 8)));
struct CanReachAddressMapping {
- CanReachAddressMapping(const string& address_a_in,
+ CanReachAddressMapping(const std::string& address_a_in,
size_t prefix_a_in,
- const string& address_b_in,
+ const std::string& address_b_in,
size_t prefix_b_in,
bool expected_result_in)
: address_a(address_a_in),
@@ -451,9 +450,9 @@
address_b(address_b_in),
prefix_b(prefix_b_in),
expected_result(expected_result_in) {}
- string address_a;
+ std::string address_a;
size_t prefix_a;
- string address_b;
+ std::string address_b;
size_t prefix_b;
size_t expected_result;
};
diff --git a/shill/net/netlink_attribute.cc b/shill/net/netlink_attribute.cc
index 8fcb46e..e36ca46 100644
--- a/shill/net/netlink_attribute.cc
+++ b/shill/net/netlink_attribute.cc
@@ -7,10 +7,7 @@
#include <linux/genetlink.h>
#include <cctype>
-#include <memory>
-#include <string>
-#include <base/callback.h>
#include <base/check.h>
#include <base/format_macros.h>
#include <base/logging.h>
@@ -19,15 +16,8 @@
#include "shill/logging.h"
#include "shill/net/attribute_list.h"
#include "shill/net/control_netlink_attribute.h"
-#include "shill/net/netlink_message.h"
#include "shill/net/nl80211_attribute.h"
-using std::string;
-using std::unique_ptr;
-
-using base::StringAppendF;
-using base::StringPrintf;
-
namespace shill {
namespace Logging {
@@ -271,12 +261,12 @@
return false;
}
-bool NetlinkAttribute::GetStringValue(string* value) const {
+bool NetlinkAttribute::GetStringValue(std::string* value) const {
LOG(ERROR) << "Attribute is not of type 'String'";
return false;
}
-bool NetlinkAttribute::SetStringValue(const string& value) {
+bool NetlinkAttribute::SetStringValue(const std::string& value) {
LOG(ERROR) << "Attribute is not of type 'String'";
return false;
}
@@ -308,37 +298,37 @@
}
void NetlinkAttribute::Print(int log_level, int indent) const {
- string attribute_value;
+ std::string attribute_value;
SLOG(this, log_level) << HeaderToPrint(indent) << " "
<< (ToString(&attribute_value) ? attribute_value
: "<DOES NOT EXIST>");
}
-string NetlinkAttribute::RawToString() const {
- string output = " === RAW: ";
+std::string NetlinkAttribute::RawToString() const {
+ std::string output = " === RAW: ";
if (!has_a_value_) {
- StringAppendF(&output, "(empty)");
+ base::StringAppendF(&output, "(empty)");
return output;
}
uint16_t length = data_.GetLength();
const uint8_t* const_data = data_.GetConstData();
- StringAppendF(&output, "len=%u", length);
+ base::StringAppendF(&output, "len=%u", length);
output.append(" DATA: ");
for (int i = 0; i < length; ++i) {
- StringAppendF(&output, "[%d]=%02x ", i, *(const_data) + i);
+ base::StringAppendF(&output, "[%d]=%02x ", i, *(const_data) + i);
}
output.append(" ==== ");
return output;
}
-string NetlinkAttribute::HeaderToPrint(int indent) const {
+std::string NetlinkAttribute::HeaderToPrint(int indent) const {
static const int kSpacesPerIndent = 2;
- return StringPrintf("%*s%s(%d) %s %s=", indent * kSpacesPerIndent, "",
- id_string(), id(), datatype_string(),
- ((has_a_value()) ? "" : "UNINITIALIZED "));
+ return base::StringPrintf("%*s%s(%d) %s %s=", indent * kSpacesPerIndent, "",
+ id_string(), id(), datatype_string(),
+ ((has_a_value()) ? "" : "UNINITIALIZED "));
}
ByteString NetlinkAttribute::EncodeGeneric(const unsigned char* data,
@@ -395,7 +385,7 @@
return true;
}
-bool NetlinkU8Attribute::ToString(string* output) const {
+bool NetlinkU8Attribute::ToString(std::string* output) const {
if (!output) {
LOG(ERROR) << "Null |output| parameter";
return false;
@@ -403,7 +393,7 @@
uint8_t value;
if (!GetU8Value(&value))
return false;
- *output = StringPrintf("%u", value);
+ *output = base::StringPrintf("%u", value);
return true;
}
@@ -449,7 +439,7 @@
return true;
}
-bool NetlinkU16Attribute::ToString(string* output) const {
+bool NetlinkU16Attribute::ToString(std::string* output) const {
if (!output) {
LOG(ERROR) << "Null |output| parameter";
return false;
@@ -457,7 +447,7 @@
uint16_t value;
if (!GetU16Value(&value))
return false;
- *output = StringPrintf("%u", value);
+ *output = base::StringPrintf("%u", value);
return true;
}
@@ -503,7 +493,7 @@
return true;
}
-bool NetlinkU32Attribute::ToString(string* output) const {
+bool NetlinkU32Attribute::ToString(std::string* output) const {
if (!output) {
LOG(ERROR) << "Null |output| parameter";
return false;
@@ -511,7 +501,7 @@
uint32_t value;
if (!GetU32Value(&value))
return false;
- *output = StringPrintf("%" PRIu32, value);
+ *output = base::StringPrintf("%" PRIu32, value);
return true;
}
@@ -556,7 +546,7 @@
return true;
}
-bool NetlinkU64Attribute::ToString(string* output) const {
+bool NetlinkU64Attribute::ToString(std::string* output) const {
if (!output) {
LOG(ERROR) << "Null |output| parameter";
return false;
@@ -564,7 +554,7 @@
uint64_t value;
if (!GetU64Value(&value))
return false;
- *output = StringPrintf("%" PRIu64, value);
+ *output = base::StringPrintf("%" PRIu64, value);
return true;
}
@@ -599,7 +589,7 @@
return true;
}
-bool NetlinkFlagAttribute::ToString(string* output) const {
+bool NetlinkFlagAttribute::ToString(std::string* output) const {
if (!output) {
LOG(ERROR) << "Null |output| parameter";
return false;
@@ -607,7 +597,7 @@
bool value;
if (!GetFlagValue(&value))
return false;
- *output = StringPrintf("%s", value ? "true" : "false");
+ *output = base::StringPrintf("%s", value ? "true" : "false");
return true;
}
@@ -642,14 +632,14 @@
SetStringValue(string_ptr);
} else {
SLOG(this, 1) << "String is unterminated.";
- SetStringValue(string(string_ptr, input.GetLength()));
+ SetStringValue(std::string(string_ptr, input.GetLength()));
}
}
return NetlinkAttribute::InitFromValue(input);
}
-bool NetlinkStringAttribute::GetStringValue(string* output) const {
+bool NetlinkStringAttribute::GetStringValue(std::string* output) const {
if (!has_a_value_) {
SLOG(this, 7) << "String attribute " << id_string()
<< " hasn't been set to any value.";
@@ -661,22 +651,22 @@
return true;
}
-bool NetlinkStringAttribute::SetStringValue(const string& new_value) {
+bool NetlinkStringAttribute::SetStringValue(const std::string& new_value) {
value_ = new_value;
has_a_value_ = true;
return true;
}
-bool NetlinkStringAttribute::ToString(string* output) const {
+bool NetlinkStringAttribute::ToString(std::string* output) const {
if (!output) {
LOG(ERROR) << "Null |output| parameter";
return false;
}
- string value;
+ std::string value;
if (!GetStringValue(&value))
return false;
- *output = StringPrintf("'%s'", value.c_str());
+ *output = base::StringPrintf("'%s'", value.c_str());
return true;
}
@@ -688,16 +678,16 @@
// SSID attribute.
-bool NetlinkSsidAttribute::ToString(string* output) const {
+bool NetlinkSsidAttribute::ToString(std::string* output) const {
if (!output) {
LOG(ERROR) << "Null |output| parameter";
return false;
}
- string value;
+ std::string value;
if (!GetStringValue(&value))
return false;
- string temp;
+ std::string temp;
for (const auto& chr : value) {
// Replace '[' and ']' (in addition to non-printable characters) so that
// it's easy to match the right substring through a non-greedy regex.
@@ -707,7 +697,7 @@
temp += chr;
}
}
- *output = StringPrintf("[SSID=%s]", temp.c_str());
+ *output = base::StringPrintf("[SSID=%s]", temp.c_str());
return true;
}
@@ -750,7 +740,7 @@
value_->Print(log_level, indent + 1);
}
-bool NetlinkNestedAttribute::ToString(string* output) const {
+bool NetlinkNestedAttribute::ToString(std::string* output) const {
if (!output) {
LOG(ERROR) << "Null |output| parameter";
return false;
@@ -829,8 +819,8 @@
const AttributeListRefPtr& list,
int id,
const ByteString& value) {
- string attribute_name =
- StringPrintf("%s_%d", array_template.attribute_name.c_str(), id);
+ auto attribute_name =
+ base::StringPrintf("%s_%d", array_template.attribute_name.c_str(), id);
return AddAttributeToNestedInner(array_template, attribute_name, list, id,
value);
}
@@ -854,7 +844,7 @@
// static
bool NetlinkNestedAttribute::AddAttributeToNestedInner(
const NetlinkNestedAttribute::NestedData& nested_template,
- const string& attribute_name,
+ const std::string& attribute_name,
const AttributeListRefPtr& list,
int id,
const ByteString& value) {
@@ -927,7 +917,7 @@
NetlinkNestedAttribute::NestedData::NestedData()
: type(kTypeRaw), attribute_name("<UNKNOWN>"), is_array(false) {}
NetlinkNestedAttribute::NestedData::NestedData(NetlinkAttribute::Type type_arg,
- string attribute_name_arg,
+ std::string attribute_name_arg,
bool is_array_arg)
: type(type_arg),
attribute_name(attribute_name_arg),
@@ -935,7 +925,7 @@
NetlinkNestedAttribute::NestedData::NestedData(
NetlinkAttribute::Type type_arg,
- string attribute_name_arg,
+ std::string attribute_name_arg,
bool is_array_arg,
const AttributeParser& parse_attribute_arg)
: type(type_arg),
@@ -975,7 +965,7 @@
return true;
}
-bool NetlinkRawAttribute::ToString(string* output) const {
+bool NetlinkRawAttribute::ToString(std::string* output) const {
if (!output) {
LOG(ERROR) << "Null |output| parameter";
return false;
@@ -988,9 +978,9 @@
int total_bytes = data_.GetLength();
const uint8_t* const_data = data_.GetConstData();
- *output = StringPrintf("%d bytes:", total_bytes);
+ *output = base::StringPrintf("%d bytes:", total_bytes);
for (int i = 0; i < total_bytes; ++i) {
- StringAppendF(output, " %02x", const_data[i]);
+ base::StringAppendF(output, " %02x", const_data[i]);
}
return true;
}
@@ -1002,7 +992,7 @@
NetlinkAttributeGeneric::NetlinkAttributeGeneric(int id)
: NetlinkRawAttribute(id, "unused-string") {
- StringAppendF(&id_string_, "<UNKNOWN ATTRIBUTE %d>", id);
+ base::StringAppendF(&id_string_, "<UNKNOWN ATTRIBUTE %d>", id);
}
const char* NetlinkAttributeGeneric::id_string() const {
diff --git a/shill/net/netlink_manager.cc b/shill/net/netlink_manager.cc
index 257d435..c3eeb47 100644
--- a/shill/net/netlink_manager.cc
+++ b/shill/net/netlink_manager.cc
@@ -8,10 +8,6 @@
#include <sys/select.h>
#include <sys/time.h>
-#include <list>
-#include <map>
-#include <queue>
-
#include <base/location.h>
#include <base/logging.h>
#include <base/stl_util.h>
@@ -19,17 +15,11 @@
#include "shill/logging.h"
#include "shill/net/attribute_list.h"
-#include "shill/net/generic_netlink_message.h"
#include "shill/net/io_handler.h"
-#include "shill/net/netlink_message.h"
#include "shill/net/netlink_packet.h"
#include "shill/net/nl80211_message.h"
-#include "shill/net/shill_time.h"
#include "shill/net/sockets.h"
-using base::Bind;
-using std::string;
-
namespace shill {
namespace Logging {
@@ -202,7 +192,7 @@
void NetlinkManager::OnNewFamilyMessage(const ControlNetlinkMessage& message) {
uint16_t family_id;
- string family_name;
+ std::string family_name;
if (!message.const_attributes()->GetU16AttributeValue(CTRL_ATTR_FAMILY_ID,
&family_id)) {
@@ -227,7 +217,7 @@
for (int i = 1;
multicast_groups->ConstGetNestedAttributeList(i, ¤t_group);
++i) {
- string group_name;
+ std::string group_name;
uint32_t group_id;
if (!current_group->GetStringAttributeValue(CTRL_ATTR_MCAST_GRP_NAME,
&group_name)) {
@@ -290,7 +280,7 @@
// statically-known message type.
message_factory_.AddFactoryMethod(
ControlNetlinkMessage::kMessageType,
- Bind(&ControlNetlinkMessage::CreateMessage));
+ base::Bind(&ControlNetlinkMessage::CreateMessage));
if (!sock_) {
sock_.reset(new NetlinkSocket);
if (!sock_) {
@@ -310,9 +300,10 @@
// IO handler will be installed to the current message loop.
dispatcher_handler_.reset(io_handler_factory_->CreateIOInputHandler(
file_descriptor(),
- Bind(&NetlinkManager::OnRawNlMessageReceived,
- weak_ptr_factory_.GetWeakPtr()),
- Bind(&NetlinkManager::OnReadError, weak_ptr_factory_.GetWeakPtr())));
+ base::Bind(&NetlinkManager::OnRawNlMessageReceived,
+ weak_ptr_factory_.GetWeakPtr()),
+ base::Bind(&NetlinkManager::OnReadError,
+ weak_ptr_factory_.GetWeakPtr())));
}
int NetlinkManager::file_descriptor() const {
@@ -320,7 +311,7 @@
}
uint16_t NetlinkManager::GetFamily(
- const string& name,
+ const std::string& name,
const NetlinkMessageFactory::FactoryMethod& message_factory) {
MessageType& message_type = message_types_[name];
if (message_type.family_id != NetlinkMessage::kIllegalMessageType) {
@@ -336,11 +327,11 @@
LOG(ERROR) << "Couldn't set string attribute";
return false;
}
- SendControlMessage(
- &msg,
- Bind(&NetlinkManager::OnNewFamilyMessage, weak_ptr_factory_.GetWeakPtr()),
- Bind(&NetlinkManager::OnAckDoNothing),
- Bind(&NetlinkManager::OnNetlinkMessageError));
+ SendControlMessage(&msg,
+ base::Bind(&NetlinkManager::OnNewFamilyMessage,
+ weak_ptr_factory_.GetWeakPtr()),
+ base::Bind(&NetlinkManager::OnAckDoNothing),
+ base::Bind(&NetlinkManager::OnNetlinkMessageError));
// Wait for a response. The code absolutely needs family_ids for its
// message types so we do a synchronous wait. It's OK to do this because
@@ -552,7 +543,7 @@
SLOG(this, 5) << "Waiting for replies to NL dump message "
<< pending_message.sequence_number;
dump_pending_ = true;
- pending_dump_timeout_callback_.Reset(Bind(
+ pending_dump_timeout_callback_.Reset(base::Bind(
&NetlinkManager::OnPendingDumpTimeout, weak_ptr_factory_.GetWeakPtr()));
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE, pending_dump_timeout_callback_.callback(),
@@ -626,8 +617,8 @@
: NetlinkMessage::kBroadcastSequenceNumber;
}
-bool NetlinkManager::SubscribeToEvents(const string& family_id,
- const string& group_name) {
+bool NetlinkManager::SubscribeToEvents(const std::string& family_id,
+ const std::string& group_name) {
if (!base::Contains(message_types_, family_id)) {
LOG(ERROR) << "Family '" << family_id << "' doesn't exist";
return false;
@@ -812,7 +803,7 @@
}
}
-void NetlinkManager::OnReadError(const string& error_msg) {
+void NetlinkManager::OnReadError(const std::string& error_msg) {
// TODO(wdg): When netlink_manager is used for scan, et al., this should
// either be LOG(FATAL) or the code should properly deal with errors,
// e.g., dropped messages due to the socket buffer being full.
@@ -824,8 +815,8 @@
SLOG(this, 3) << "Resending NL dump message " << PendingDumpSequenceNumber()
<< " after " << kNlMessageRetryDelayMilliseconds << " ms";
resend_dump_message_callback_.Reset(
- Bind(&NetlinkManager::ResendPendingDumpMessage,
- weak_ptr_factory_.GetWeakPtr()));
+ base::Bind(&NetlinkManager::ResendPendingDumpMessage,
+ weak_ptr_factory_.GetWeakPtr()));
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE, resend_dump_message_callback_.callback(),
base::TimeDelta::FromMilliseconds(kNlMessageRetryDelayMilliseconds));
diff --git a/shill/net/netlink_manager.h b/shill/net/netlink_manager.h
index 2c1de30..73db980 100644
--- a/shill/net/netlink_manager.h
+++ b/shill/net/netlink_manager.h
@@ -155,7 +155,6 @@
private:
NetlinkAuxilliaryMessageHandler error_handler_;
struct timeval delete_after_;
-
};
// Encapsulates all the different things we know about a specific message
diff --git a/shill/net/netlink_manager_test.cc b/shill/net/netlink_manager_test.cc
index 8774486..8af5eec 100644
--- a/shill/net/netlink_manager_test.cc
+++ b/shill/net/netlink_manager_test.cc
@@ -29,10 +29,6 @@
#include "shill/net/netlink_packet.h"
#include "shill/net/nl80211_message.h"
-using base::Bind;
-using std::map;
-using std::string;
-using std::vector;
using testing::_;
using testing::Invoke;
using testing::Mock;
@@ -106,13 +102,14 @@
netlink_manager_->message_types_[kFamilyMarxString].family_id =
kFamilyMarxNumber;
netlink_manager_->message_types_[kFamilyMarxString].groups =
- map<string, uint32_t>{{kGroupGrouchoString, kGroupGrouchoNumber},
- {kGroupHarpoString, kGroupHarpoNumber},
- {kGroupChicoString, kGroupChicoNumber},
- {kGroupZeppoString, kGroupZeppoNumber},
- {kGroupGummoString, kGroupGummoNumber}};
+ std::map<std::string, uint32_t>{
+ {kGroupGrouchoString, kGroupGrouchoNumber},
+ {kGroupHarpoString, kGroupHarpoNumber},
+ {kGroupChicoString, kGroupChicoNumber},
+ {kGroupZeppoString, kGroupZeppoNumber},
+ {kGroupGummoString, kGroupGummoNumber}};
netlink_manager_->message_factory_.AddFactoryMethod(
- kNl80211FamilyId, Bind(&Nl80211Message::CreateMessage));
+ kNl80211FamilyId, base::Bind(&Nl80211Message::CreateMessage));
Nl80211Message::SetMessageType(kNl80211FamilyId);
netlink_socket_->sockets_.reset(sockets_); // Passes ownership.
netlink_manager_->sock_.reset(netlink_socket_); // Passes ownership.
@@ -328,7 +325,7 @@
TEST_F(NetlinkManagerTest, GetFamily) {
const uint16_t kSampleMessageType = 42;
- const string kSampleMessageName("SampleMessageName");
+ const std::string kSampleMessageName = "SampleMessageName";
const uint32_t kRandomSequenceNumber = 3;
NewFamilyMessage new_family_message;
@@ -357,7 +354,7 @@
Reset();
const uint16_t kSampleMessageType = 42;
- const string kSampleMessageName("SampleMessageName");
+ const std::string kSampleMessageName = "SampleMessageName";
const uint32_t kRandomSequenceNumber = 3;
NewFamilyMessage new_family_message;
@@ -407,7 +404,7 @@
Invoke(this, &NetlinkManagerTest::ReplyWithRandomMessage));
NetlinkMessageFactory::FactoryMethod null_factory;
- const string kSampleMessageName("SampleMessageName");
+ const std::string kSampleMessageName = "SampleMessageName";
EXPECT_EQ(NetlinkMessage::kIllegalMessageType,
netlink_manager_->GetFamily(kSampleMessageName, null_factory));
netlink_manager_->time_ = old_time;
@@ -1071,9 +1068,10 @@
MockHandlerNetlink message_handler;
netlink_manager_->AddBroadcastHandler(message_handler.on_netlink_message());
- vector<unsigned char> bad_len_message{0x01}; // len should be 32-bits
- vector<unsigned char> bad_hdr_message{0x04, 0x00, 0x00, 0x00}; // only len
- vector<unsigned char> bad_body_message{
+ std::vector<unsigned char> bad_len_message{0x01}; // len should be 32-bits
+ std::vector<unsigned char> bad_hdr_message{0x04, 0x00, 0x00,
+ 0x00}; // only len
+ std::vector<unsigned char> bad_body_message{
0x30, 0x00, 0x00, 0x00, // length
0x00, 0x00, // type
0x00, 0x00, // flags
@@ -1089,7 +1087,7 @@
Mock::VerifyAndClearExpectations(&message_handler);
}
- vector<unsigned char> good_message{
+ std::vector<unsigned char> good_message{
0x14, 0x00, 0x00, 0x00, // length
0x00, 0x00, // type
0x00, 0x00, // flags
@@ -1101,8 +1099,8 @@
for (auto bad_msg : {bad_len_message, bad_hdr_message, bad_body_message}) {
// A good message followed by a bad message. This should yield one call
// to |message_handler|, and one error message.
- vector<unsigned char> two_messages(good_message.begin(),
- good_message.end());
+ std::vector<unsigned char> two_messages(good_message.begin(),
+ good_message.end());
two_messages.insert(two_messages.end(), bad_msg.begin(), bad_msg.end());
EXPECT_CALL(message_handler, OnNetlinkMessage(_)).Times(1);
InputData data(two_messages.data(), two_messages.size());
diff --git a/shill/net/netlink_message.cc b/shill/net/netlink_message.cc
index 71ec4a3..3c527ca 100644
--- a/shill/net/netlink_message.cc
+++ b/shill/net/netlink_message.cc
@@ -7,9 +7,6 @@
#include <limits.h>
#include <algorithm>
-#include <map>
-#include <memory>
-#include <string>
#include <base/format_macros.h>
#include <base/logging.h>
@@ -19,9 +16,6 @@
#include "shill/logging.h"
#include "shill/net/netlink_packet.h"
-using base::StringAppendF;
-using base::StringPrintf;
-
namespace shill {
namespace Logging {
@@ -124,11 +118,11 @@
// static
void NetlinkMessage::PrintHeader(int log_level, const nlmsghdr* header) {
const unsigned char* buf = reinterpret_cast<const unsigned char*>(header);
- SLOG(nullptr, log_level) << StringPrintf(
+ SLOG(nullptr, log_level) << base::StringPrintf(
"len: %02x %02x %02x %02x = %u bytes", buf[0], buf[1], buf[2],
buf[3], header->nlmsg_len);
- SLOG(nullptr, log_level) << StringPrintf(
+ SLOG(nullptr, log_level) << base::StringPrintf(
"type | flags: %02x %02x %02x %02x - type:%u flags:%s%s%s%s%s", buf[4],
buf[5], buf[6], buf[7], header->nlmsg_type,
((header->nlmsg_flags & NLM_F_REQUEST) ? " REQUEST" : ""),
@@ -137,10 +131,10 @@
((header->nlmsg_flags & NLM_F_ECHO) ? " ECHO" : ""),
((header->nlmsg_flags & NLM_F_DUMP_INTR) ? " BAD-SEQ" : ""));
- SLOG(nullptr, log_level) << StringPrintf(
+ SLOG(nullptr, log_level) << base::StringPrintf(
"sequence: %02x %02x %02x %02x = %u", buf[8], buf[9], buf[10],
buf[11], header->nlmsg_seq);
- SLOG(nullptr, log_level) << StringPrintf(
+ SLOG(nullptr, log_level) << base::StringPrintf(
"pid: %02x %02x %02x %02x = %u", buf[12], buf[13], buf[14],
buf[15], header->nlmsg_pid);
}
@@ -153,7 +147,7 @@
std::string output;
size_t bytes_this_row = std::min(num_bytes, static_cast<size_t>(32));
for (size_t i = 0; i < bytes_this_row; ++i) {
- StringAppendF(&output, " %02x", *buf++);
+ base::StringAppendF(&output, " %02x", *buf++);
}
SLOG(nullptr, log_level) << output;
num_bytes -= bytes_this_row;
@@ -186,10 +180,10 @@
std::string ErrorAckMessage::ToString() const {
std::string output;
if (error()) {
- StringAppendF(&output, "NETLINK_ERROR 0x%" PRIx32 ": %s", -error_,
- strerror(-error_));
+ base::StringAppendF(&output, "NETLINK_ERROR 0x%" PRIx32 ": %s", -error_,
+ strerror(-error_));
} else {
- StringAppendF(&output, "ACK");
+ base::StringAppendF(&output, "ACK");
}
return output;
}
@@ -250,9 +244,9 @@
int total_bytes = message_body_.GetLength();
const uint8_t* const_data = message_body_.GetConstData();
- std::string output = StringPrintf("%d bytes:", total_bytes);
+ std::string output = base::StringPrintf("%d bytes:", total_bytes);
for (int i = 0; i < total_bytes; ++i) {
- StringAppendF(&output, " %02x", const_data[i]);
+ base::StringAppendF(&output, " %02x", const_data[i]);
}
SLOG(this, header_log_level) << output;
}
diff --git a/shill/net/netlink_message_test.cc b/shill/net/netlink_message_test.cc
index a3e7313..d52bf49 100644
--- a/shill/net/netlink_message_test.cc
+++ b/shill/net/netlink_message_test.cc
@@ -23,10 +23,6 @@
#include "shill/net/netlink_attribute.h"
#include "shill/net/netlink_packet.h"
-using base::Bind;
-using std::string;
-using std::unique_ptr;
-using std::vector;
using testing::_;
using testing::Test;
@@ -280,8 +276,8 @@
class NetlinkMessageTest : public Test {
public:
NetlinkMessageTest() {
- message_factory_.AddFactoryMethod(kNl80211FamilyId,
- Bind(&Nl80211Message::CreateMessage));
+ message_factory_.AddFactoryMethod(
+ kNl80211FamilyId, base::Bind(&Nl80211Message::CreateMessage));
Nl80211Message::SetMessageType(kNl80211FamilyId);
}
@@ -289,7 +285,7 @@
// Helper function to provide an array of scan frequencies from a message's
// NL80211_ATTR_SCAN_FREQUENCIES attribute.
static bool GetScanFrequenciesFromMessage(const Nl80211Message& message,
- vector<uint32_t>* value) {
+ std::vector<uint32_t>* value) {
if (!value) {
LOG(ERROR) << "Null |value| parameter";
return false;
@@ -317,7 +313,7 @@
// Helper function to provide an array of SSIDs from a message's
// NL80211_ATTR_SCAN_SSIDS attribute.
static bool GetScanSsidsFromMessage(const Nl80211Message& message,
- vector<string>* value) {
+ std::vector<std::string>* value) {
if (!value) {
LOG(ERROR) << "Null |value| parameter";
return false;
@@ -339,7 +335,8 @@
if (bytes.IsEmpty()) {
value->push_back("");
} else {
- value->push_back(string(bytes.GetConstCString(), bytes.GetLength()));
+ value->push_back(
+ std::string(bytes.GetConstCString(), bytes.GetLength()));
}
}
}
@@ -352,13 +349,14 @@
TEST_F(NetlinkMessageTest, Parse_NL80211_CMD_TRIGGER_SCAN) {
NetlinkPacket trigger_scan_packet(kNL80211_CMD_TRIGGER_SCAN,
sizeof(kNL80211_CMD_TRIGGER_SCAN));
- unique_ptr<NetlinkMessage> netlink_message(message_factory_.CreateMessage(
- &trigger_scan_packet, NetlinkMessage::MessageContext()));
+ std::unique_ptr<NetlinkMessage> netlink_message(
+ message_factory_.CreateMessage(&trigger_scan_packet,
+ NetlinkMessage::MessageContext()));
EXPECT_NE(nullptr, netlink_message);
EXPECT_EQ(kNl80211FamilyId, netlink_message->message_type());
// The following is legal if the message_type is kNl80211FamilyId.
- unique_ptr<Nl80211Message> message(
+ std::unique_ptr<Nl80211Message> message(
static_cast<Nl80211Message*>(netlink_message.release()));
EXPECT_EQ(NL80211_CMD_TRIGGER_SCAN, message->command());
@@ -379,11 +377,11 @@
// Make sure the scan frequencies in the attribute are the ones we expect.
{
- vector<uint32_t> list;
+ std::vector<uint32_t> list;
EXPECT_TRUE(GetScanFrequenciesFromMessage(*message, &list));
EXPECT_EQ(list.size(), base::size(kScanFrequencyTrigger));
int i = 0;
- vector<uint32_t>::const_iterator j = list.begin();
+ auto j = list.begin();
while (j != list.end()) {
EXPECT_EQ(kScanFrequencyTrigger[i], *j);
++i;
@@ -392,7 +390,7 @@
}
{
- vector<string> ssids;
+ std::vector<std::string> ssids;
EXPECT_TRUE(GetScanSsidsFromMessage(*message, &ssids));
EXPECT_EQ(1, ssids.size());
EXPECT_EQ(0, ssids[0].compare("")); // Expect a single, empty SSID.
@@ -405,13 +403,14 @@
TEST_F(NetlinkMessageTest, Parse_NL80211_CMD_NEW_SCAN_RESULTS) {
NetlinkPacket new_scan_results_packet(kNL80211_CMD_NEW_SCAN_RESULTS,
sizeof(kNL80211_CMD_NEW_SCAN_RESULTS));
- unique_ptr<NetlinkMessage> netlink_message(message_factory_.CreateMessage(
- &new_scan_results_packet, NetlinkMessage::MessageContext()));
+ std::unique_ptr<NetlinkMessage> netlink_message(
+ message_factory_.CreateMessage(&new_scan_results_packet,
+ NetlinkMessage::MessageContext()));
EXPECT_NE(nullptr, netlink_message);
EXPECT_EQ(kNl80211FamilyId, netlink_message->message_type());
// The following is legal if the message_type is kNl80211FamilyId.
- unique_ptr<Nl80211Message> message(
+ std::unique_ptr<Nl80211Message> message(
static_cast<Nl80211Message*>(netlink_message.release()));
EXPECT_EQ(NL80211_CMD_NEW_SCAN_RESULTS, message->command());
@@ -432,11 +431,11 @@
// Make sure the scan frequencies in the attribute are the ones we expect.
{
- vector<uint32_t> list;
+ std::vector<uint32_t> list;
EXPECT_TRUE(GetScanFrequenciesFromMessage(*message, &list));
EXPECT_EQ(base::size(kScanFrequencyResults), list.size());
int i = 0;
- vector<uint32_t>::const_iterator j = list.begin();
+ auto j = list.begin();
while (j != list.end()) {
EXPECT_EQ(kScanFrequencyResults[i], *j);
++i;
@@ -445,7 +444,7 @@
}
{
- vector<string> ssids;
+ std::vector<std::string> ssids;
EXPECT_TRUE(GetScanSsidsFromMessage(*message, &ssids));
EXPECT_EQ(1, ssids.size());
EXPECT_EQ(0, ssids[0].compare("")); // Expect a single, empty SSID.
@@ -458,13 +457,14 @@
TEST_F(NetlinkMessageTest, Parse_NL80211_CMD_NEW_STATION) {
NetlinkPacket netlink_packet(kNL80211_CMD_NEW_STATION,
sizeof(kNL80211_CMD_NEW_STATION));
- unique_ptr<NetlinkMessage> netlink_message(message_factory_.CreateMessage(
- &netlink_packet, NetlinkMessage::MessageContext()));
+ std::unique_ptr<NetlinkMessage> netlink_message(
+ message_factory_.CreateMessage(&netlink_packet,
+ NetlinkMessage::MessageContext()));
EXPECT_NE(nullptr, netlink_message);
EXPECT_EQ(kNl80211FamilyId, netlink_message->message_type());
// The following is legal if the message_type is kNl80211FamilyId.
- unique_ptr<Nl80211Message> message(
+ std::unique_ptr<Nl80211Message> message(
static_cast<Nl80211Message*>(netlink_message.release()));
EXPECT_EQ(NL80211_CMD_NEW_STATION, message->command());
@@ -476,7 +476,7 @@
}
{
- string value;
+ std::string value;
EXPECT_TRUE(message->const_attributes()->GetAttributeAsString(
NL80211_ATTR_MAC, &value));
EXPECT_EQ(0, strncmp(value.c_str(), kExpectedMacAddress, value.length()));
@@ -499,13 +499,14 @@
TEST_F(NetlinkMessageTest, Parse_NL80211_CMD_AUTHENTICATE) {
NetlinkPacket netlink_packet(kNL80211_CMD_AUTHENTICATE,
sizeof(kNL80211_CMD_AUTHENTICATE));
- unique_ptr<NetlinkMessage> netlink_message(message_factory_.CreateMessage(
- &netlink_packet, NetlinkMessage::MessageContext()));
+ std::unique_ptr<NetlinkMessage> netlink_message(
+ message_factory_.CreateMessage(&netlink_packet,
+ NetlinkMessage::MessageContext()));
EXPECT_NE(nullptr, netlink_message);
EXPECT_EQ(kNl80211FamilyId, netlink_message->message_type());
// The following is legal if the message_type is kNl80211FamilyId.
- unique_ptr<Nl80211Message> message(
+ std::unique_ptr<Nl80211Message> message(
static_cast<Nl80211Message*>(netlink_message.release()));
EXPECT_EQ(NL80211_CMD_AUTHENTICATE, message->command());
@@ -539,13 +540,14 @@
TEST_F(NetlinkMessageTest, Parse_NL80211_CMD_ASSOCIATE) {
NetlinkPacket netlink_packet(kNL80211_CMD_ASSOCIATE,
sizeof(kNL80211_CMD_ASSOCIATE));
- unique_ptr<NetlinkMessage> netlink_message(message_factory_.CreateMessage(
- &netlink_packet, NetlinkMessage::MessageContext()));
+ std::unique_ptr<NetlinkMessage> netlink_message(
+ message_factory_.CreateMessage(&netlink_packet,
+ NetlinkMessage::MessageContext()));
EXPECT_NE(nullptr, netlink_message);
EXPECT_EQ(kNl80211FamilyId, netlink_message->message_type());
// The following is legal if the message_type is kNl80211FamilyId.
- unique_ptr<Nl80211Message> message(
+ std::unique_ptr<Nl80211Message> message(
static_cast<Nl80211Message*>(netlink_message.release()));
EXPECT_EQ(NL80211_CMD_ASSOCIATE, message->command());
@@ -579,13 +581,14 @@
TEST_F(NetlinkMessageTest, Parse_NL80211_CMD_CONNECT) {
NetlinkPacket netlink_packet(kNL80211_CMD_CONNECT,
sizeof(kNL80211_CMD_CONNECT));
- unique_ptr<NetlinkMessage> netlink_message(message_factory_.CreateMessage(
- &netlink_packet, NetlinkMessage::MessageContext()));
+ std::unique_ptr<NetlinkMessage> netlink_message(
+ message_factory_.CreateMessage(&netlink_packet,
+ NetlinkMessage::MessageContext()));
EXPECT_NE(nullptr, netlink_message);
EXPECT_EQ(kNl80211FamilyId, netlink_message->message_type());
// The following is legal if the message_type is kNl80211FamilyId.
- unique_ptr<Nl80211Message> message(
+ std::unique_ptr<Nl80211Message> message(
static_cast<Nl80211Message*>(netlink_message.release()));
EXPECT_EQ(NL80211_CMD_CONNECT, message->command());
@@ -604,7 +607,7 @@
}
{
- string value;
+ std::string value;
EXPECT_TRUE(message->const_attributes()->GetAttributeAsString(
NL80211_ATTR_MAC, &value));
EXPECT_EQ(0, strncmp(value.c_str(), kExpectedMacAddress, value.length()));
@@ -677,13 +680,14 @@
TEST_F(NetlinkMessageTest, Parse_NL80211_CMD_DEAUTHENTICATE) {
NetlinkPacket netlink_packet(kNL80211_CMD_DEAUTHENTICATE,
sizeof(kNL80211_CMD_DEAUTHENTICATE));
- unique_ptr<NetlinkMessage> netlink_message(message_factory_.CreateMessage(
- &netlink_packet, NetlinkMessage::MessageContext()));
+ std::unique_ptr<NetlinkMessage> netlink_message(
+ message_factory_.CreateMessage(&netlink_packet,
+ NetlinkMessage::MessageContext()));
EXPECT_NE(nullptr, netlink_message);
EXPECT_EQ(kNl80211FamilyId, netlink_message->message_type());
// The following is legal if the message_type is kNl80211FamilyId.
- unique_ptr<Nl80211Message> message(
+ std::unique_ptr<Nl80211Message> message(
static_cast<Nl80211Message*>(netlink_message.release()));
EXPECT_EQ(NL80211_CMD_DEAUTHENTICATE, message->command());
@@ -717,13 +721,14 @@
TEST_F(NetlinkMessageTest, Parse_NL80211_CMD_DISCONNECT) {
NetlinkPacket netlink_packet(kNL80211_CMD_DISCONNECT,
sizeof(kNL80211_CMD_DISCONNECT));
- unique_ptr<NetlinkMessage> netlink_message(message_factory_.CreateMessage(
- &netlink_packet, NetlinkMessage::MessageContext()));
+ std::unique_ptr<NetlinkMessage> netlink_message(
+ message_factory_.CreateMessage(&netlink_packet,
+ NetlinkMessage::MessageContext()));
EXPECT_NE(nullptr, netlink_message);
EXPECT_EQ(kNl80211FamilyId, netlink_message->message_type());
// The following is legal if the message_type is kNl80211FamilyId.
- unique_ptr<Nl80211Message> message(
+ std::unique_ptr<Nl80211Message> message(
static_cast<Nl80211Message*>(netlink_message.release()));
EXPECT_EQ(NL80211_CMD_DISCONNECT, message->command());
@@ -755,13 +760,14 @@
TEST_F(NetlinkMessageTest, Parse_NL80211_CMD_NOTIFY_CQM) {
NetlinkPacket netlink_packet(kNL80211_CMD_NOTIFY_CQM,
sizeof(kNL80211_CMD_NOTIFY_CQM));
- unique_ptr<NetlinkMessage> netlink_message(message_factory_.CreateMessage(
- &netlink_packet, NetlinkMessage::MessageContext()));
+ std::unique_ptr<NetlinkMessage> netlink_message(
+ message_factory_.CreateMessage(&netlink_packet,
+ NetlinkMessage::MessageContext()));
EXPECT_NE(nullptr, netlink_message);
EXPECT_EQ(kNl80211FamilyId, netlink_message->message_type());
// The following is legal if the message_type is kNl80211FamilyId.
- unique_ptr<Nl80211Message> message(
+ std::unique_ptr<Nl80211Message> message(
static_cast<Nl80211Message*>(netlink_message.release()));
EXPECT_EQ(NL80211_CMD_NOTIFY_CQM, message->command());
@@ -780,7 +786,7 @@
}
{
- string value;
+ std::string value;
EXPECT_TRUE(message->const_attributes()->GetAttributeAsString(
NL80211_ATTR_MAC, &value));
EXPECT_EQ(0, strncmp(value.c_str(), kExpectedMacAddress, value.length()));
@@ -803,13 +809,14 @@
TEST_F(NetlinkMessageTest, Parse_NL80211_CMD_DISASSOCIATE) {
NetlinkPacket netlink_packet(kNL80211_CMD_DISASSOCIATE,
sizeof(kNL80211_CMD_DISASSOCIATE));
- unique_ptr<NetlinkMessage> netlink_message(message_factory_.CreateMessage(
- &netlink_packet, NetlinkMessage::MessageContext()));
+ std::unique_ptr<NetlinkMessage> netlink_message(
+ message_factory_.CreateMessage(&netlink_packet,
+ NetlinkMessage::MessageContext()));
EXPECT_NE(nullptr, netlink_message);
EXPECT_EQ(kNl80211FamilyId, netlink_message->message_type());
// The following is legal if the message_type is kNl80211FamilyId.
- unique_ptr<Nl80211Message> message(
+ std::unique_ptr<Nl80211Message> message(
static_cast<Nl80211Message*>(netlink_message.release()));
EXPECT_EQ(NL80211_CMD_DISASSOCIATE, message->command());
@@ -845,12 +852,13 @@
TEST_F(NetlinkMessageTest, Parse_NL80211_CMD_UNKNOWN) {
NetlinkPacket netlink_packet(kNL80211_CMD_UNKNOWN,
sizeof(kNL80211_CMD_UNKNOWN));
- unique_ptr<NetlinkMessage> netlink_message(message_factory_.CreateMessage(
- &netlink_packet, NetlinkMessage::MessageContext()));
+ std::unique_ptr<NetlinkMessage> netlink_message(
+ message_factory_.CreateMessage(&netlink_packet,
+ NetlinkMessage::MessageContext()));
ASSERT_NE(nullptr, netlink_message);
EXPECT_EQ(kNl80211FamilyId, netlink_message->message_type());
// The following is legal if the message_type is kNl80211FamilyId.
- unique_ptr<Nl80211Message> message(
+ std::unique_ptr<Nl80211Message> message(
static_cast<Nl80211Message*>(netlink_message.release()));
EXPECT_EQ(kCmdNL80211_CMD_UNKNOWN, message->command());
}
diff --git a/shill/net/netlink_socket_test.cc b/shill/net/netlink_socket_test.cc
index 5dd0f32..4137fb3 100644
--- a/shill/net/netlink_socket_test.cc
+++ b/shill/net/netlink_socket_test.cc
@@ -17,8 +17,6 @@
#include "shill/net/netlink_fd.h"
#include "shill/net/netlink_message.h"
-using std::min;
-using std::string;
using testing::_;
using testing::Invoke;
using testing::Return;
@@ -70,7 +68,7 @@
if (!buf) {
return -1;
}
- int read_bytes = min(len, next_read_string_.GetLength());
+ int read_bytes = std::min(len, next_read_string_.GetLength());
memcpy(buf, next_read_string_.GetConstData(), read_bytes);
next_read_string_.Clear();
return read_bytes;
@@ -131,7 +129,7 @@
SetUp();
InitializeSocket(kFakeFd);
- string message_string("This text is really arbitrary");
+ std::string message_string = "This text is really arbitrary";
ByteString message(message_string.c_str(), message_string.size());
// Good Send.
@@ -175,8 +173,8 @@
InitializeSocket(kFakeFd);
ByteString message;
- static const string next_read_string(
- "Random text may include things like 'freaking fracking foo'.");
+ static const std::string next_read_string =
+ "Random text may include things like 'freaking fracking foo'.";
static const size_t read_size = next_read_string.size();
ByteString expected_results(next_read_string.c_str(), read_size);
FakeSocketRead fake_socket_read(expected_results);
diff --git a/shill/net/nl80211_attribute.cc b/shill/net/nl80211_attribute.cc
index 7ca8964..3d246e9 100644
--- a/shill/net/nl80211_attribute.cc
+++ b/shill/net/nl80211_attribute.cc
@@ -4,19 +4,12 @@
#include "shill/net/nl80211_attribute.h"
-#include <string>
-
#include <base/bind.h>
#include <base/format_macros.h>
#include <base/logging.h>
#include <base/strings/stringprintf.h>
#include "shill/net/ieee80211.h"
-#include "shill/net/netlink_message.h"
-
-using base::Bind;
-using base::StringPrintf;
-using std::string;
namespace shill {
@@ -85,7 +78,7 @@
nested_template_.insert(AttrDataPair(
NL80211_BSS_INFORMATION_ELEMENTS,
NestedData(kTypeRaw, "NL80211_BSS_INFORMATION_ELEMENTS", false,
- Bind(&Nl80211AttributeBss::ParseInformationElements))));
+ base::Bind(&Nl80211AttributeBss::ParseInformationElements))));
nested_template_.insert(
AttrDataPair(NL80211_BSS_SIGNAL_MBM,
NestedData(kTypeU32, "NL80211_BSS_SIGNAL_MBM", false)));
@@ -102,7 +95,7 @@
bool Nl80211AttributeBss::ParseInformationElements(
AttributeList* attribute_list,
size_t id,
- const string& attribute_name,
+ const std::string& attribute_name,
ByteString data) {
if (!attribute_list) {
LOG(ERROR) << "NULL |attribute_list| parameter";
@@ -138,8 +131,8 @@
ie_attribute->SetStringAttributeValue(type, "");
} else {
ie_attribute->SetStringAttributeValue(
- type,
- string(reinterpret_cast<const char*>(payload), payload_bytes));
+ type, std::string(reinterpret_cast<const char*>(payload),
+ payload_bytes));
}
break;
}
@@ -155,7 +148,7 @@
}
// Extract each rate, add it to the list.
for (size_t i = 0; i < payload_bytes; ++i) {
- string rate_name = StringPrintf("Rate-%zu", i);
+ std::string rate_name = base::StringPrintf("Rate-%zu", i);
rates_attribute->CreateU8Attribute(i, rate_name.c_str());
rates_attribute->SetU8AttributeValue(i, payload[i]);
}
@@ -196,8 +189,8 @@
ie_attribute->SetStringAttributeValue(type, "");
} else {
ie_attribute->SetStringAttributeValue(
- type,
- string(reinterpret_cast<const char*>(payload), payload_bytes));
+ type, std::string(reinterpret_cast<const char*>(payload),
+ payload_bytes));
}
break;
}
@@ -482,16 +475,16 @@
}
// static
-string Nl80211AttributeMac::StringFromMacAddress(const uint8_t* arg) {
- string output;
+std::string Nl80211AttributeMac::StringFromMacAddress(const uint8_t* arg) {
+ std::string output;
if (!arg) {
static const char kBogusMacAddress[] = "XX:XX:XX:XX:XX:XX";
output = kBogusMacAddress;
LOG(ERROR) << "|arg| parameter is NULL.";
} else {
- output = StringPrintf("%02x:%02x:%02x:%02x:%02x:%02x", arg[0], arg[1],
- arg[2], arg[3], arg[4], arg[5]);
+ output = base::StringPrintf("%02x:%02x:%02x:%02x:%02x:%02x", arg[0], arg[1],
+ arg[2], arg[3], arg[4], arg[5]);
}
return output;
}
diff --git a/shill/net/nl80211_message.cc b/shill/net/nl80211_message.cc
index b0b0f01..214d259 100644
--- a/shill/net/nl80211_message.cc
+++ b/shill/net/nl80211_message.cc
@@ -26,8 +26,6 @@
#include <iomanip>
#include <limits>
-#include <memory>
-#include <string>
#include <base/bind.h>
#include <base/logging.h>
@@ -40,10 +38,6 @@
#include "shill/net/netlink_packet.h"
#include "shill/net/nl80211_attribute.h" // For Nl80211AttributeMac
-using base::Bind;
-using base::StringAppendF;
-using std::string;
-
namespace shill {
const uint8_t Nl80211Frame::kFrameTypeMask = 0xfc;
@@ -76,7 +70,8 @@
}
return packet->ConsumeAttributes(
- Bind(&NetlinkAttribute::NewNl80211AttributeFromId, context), attributes_);
+ base::Bind(&NetlinkAttribute::NewNl80211AttributeFromId, context),
+ attributes_);
}
Nl80211Frame::Nl80211Frame(const ByteString& raw_frame)
@@ -142,39 +137,45 @@
if (frame_.GetLength() < sizeof(IEEE_80211::ieee80211_frame().hdr)) {
output.append("[invalid frame: ");
} else {
- StringAppendF(&output, "%s -> %s", mac_from_.c_str(), mac_to_.c_str());
+ base::StringAppendF(&output, "%s -> %s", mac_from_.c_str(),
+ mac_to_.c_str());
switch (frame_type_) {
case kAssocResponseFrameType:
- StringAppendF(&output, "; AssocResponse status: %u: %s", status_,
- IEEE_80211::StatusToString(
- static_cast<IEEE_80211::WiFiStatusCode>(status_))
- .c_str());
+ base::StringAppendF(
+ &output, "; AssocResponse status: %u: %s", status_,
+ IEEE_80211::StatusToString(
+ static_cast<IEEE_80211::WiFiStatusCode>(status_))
+ .c_str());
break;
case kReassocResponseFrameType:
- StringAppendF(&output, "; ReassocResponse status: %u: %s", status_,
- IEEE_80211::StatusToString(
- static_cast<IEEE_80211::WiFiStatusCode>(status_))
- .c_str());
+ base::StringAppendF(
+ &output, "; ReassocResponse status: %u: %s", status_,
+ IEEE_80211::StatusToString(
+ static_cast<IEEE_80211::WiFiStatusCode>(status_))
+ .c_str());
break;
case kAuthFrameType:
- StringAppendF(&output, "; Auth status: %u: %s", status_,
- IEEE_80211::StatusToString(
- static_cast<IEEE_80211::WiFiStatusCode>(status_))
- .c_str());
+ base::StringAppendF(
+ &output, "; Auth status: %u: %s", status_,
+ IEEE_80211::StatusToString(
+ static_cast<IEEE_80211::WiFiStatusCode>(status_))
+ .c_str());
break;
case kDisassocFrameType:
- StringAppendF(&output, "; Disassoc reason %u: %s", reason_,
- IEEE_80211::ReasonToString(
- static_cast<IEEE_80211::WiFiReasonCode>(reason_))
- .c_str());
+ base::StringAppendF(
+ &output, "; Disassoc reason %u: %s", reason_,
+ IEEE_80211::ReasonToString(
+ static_cast<IEEE_80211::WiFiReasonCode>(reason_))
+ .c_str());
break;
case kDeauthFrameType:
- StringAppendF(&output, "; Deauth reason %u: %s", reason_,
- IEEE_80211::ReasonToString(
- static_cast<IEEE_80211::WiFiReasonCode>(reason_))
- .c_str());
+ base::StringAppendF(
+ &output, "; Deauth reason %u: %s", reason_,
+ IEEE_80211::ReasonToString(
+ static_cast<IEEE_80211::WiFiReasonCode>(reason_))
+ .c_str());
break;
default:
@@ -185,7 +186,7 @@
const unsigned char* frame = frame_.GetConstData();
for (size_t i = 0; i < frame_.GetLength(); ++i) {
- StringAppendF(&output, "%02x, ", frame[i]);
+ base::StringAppendF(&output, "%02x, ", frame[i]);
}
output.append("]");
@@ -239,8 +240,9 @@
GetRegMessage::GetRegMessage() : Nl80211Message(kCommand, kCommandString) {
attributes()->CreateAttribute(
- NL80211_ATTR_WIPHY, Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
- NetlinkMessage::MessageContext()));
+ NL80211_ATTR_WIPHY,
+ base::Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
+ NetlinkMessage::MessageContext()));
}
const uint8_t GetStationMessage::kCommand = NL80211_CMD_GET_STATION;
@@ -249,11 +251,12 @@
GetStationMessage::GetStationMessage()
: Nl80211Message(kCommand, kCommandString) {
attributes()->CreateAttribute(
- NL80211_ATTR_IFINDEX, Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
- NetlinkMessage::MessageContext()));
+ NL80211_ATTR_IFINDEX,
+ base::Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
+ NetlinkMessage::MessageContext()));
attributes()->CreateAttribute(
- NL80211_ATTR_MAC, Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
- NetlinkMessage::MessageContext()));
+ NL80211_ATTR_MAC, base::Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
+ NetlinkMessage::MessageContext()));
}
const uint8_t SetWakeOnPacketConnMessage::kCommand = NL80211_CMD_SET_WOWLAN;
@@ -269,8 +272,9 @@
GetWiphyMessage::GetWiphyMessage() : Nl80211Message(kCommand, kCommandString) {
attributes()->CreateAttribute(
- NL80211_ATTR_IFINDEX, Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
- NetlinkMessage::MessageContext()));
+ NL80211_ATTR_IFINDEX,
+ base::Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
+ NetlinkMessage::MessageContext()));
}
const uint8_t JoinIbssMessage::kCommand = NL80211_CMD_JOIN_IBSS;
@@ -308,14 +312,16 @@
ProbeMeshLinkMessage::ProbeMeshLinkMessage()
: Nl80211Message(kCommand, kCommandString) {
attributes()->CreateAttribute(
- NL80211_ATTR_IFINDEX, Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
- NetlinkMessage::MessageContext()));
+ NL80211_ATTR_IFINDEX,
+ base::Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
+ NetlinkMessage::MessageContext()));
attributes()->CreateAttribute(
- NL80211_ATTR_MAC, Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
- NetlinkMessage::MessageContext()));
+ NL80211_ATTR_MAC, base::Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
+ NetlinkMessage::MessageContext()));
attributes()->CreateAttribute(
- NL80211_ATTR_FRAME, Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
- NetlinkMessage::MessageContext()));
+ NL80211_ATTR_FRAME,
+ base::Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
+ NetlinkMessage::MessageContext()));
}
const uint8_t RegBeaconHintMessage::kCommand = NL80211_CMD_REG_BEACON_HINT;
@@ -328,8 +334,9 @@
RegChangeMessage::RegChangeMessage()
: Nl80211Message(kCommand, kCommandString) {
attributes()->CreateAttribute(
- NL80211_ATTR_IFINDEX, Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
- NetlinkMessage::MessageContext()));
+ NL80211_ATTR_IFINDEX,
+ base::Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
+ NetlinkMessage::MessageContext()));
}
const uint8_t RemainOnChannelMessage::kCommand = NL80211_CMD_REMAIN_ON_CHANNEL;
@@ -347,8 +354,9 @@
GetScanMessage::GetScanMessage() : Nl80211Message(kCommand, kCommandString) {
attributes()->CreateAttribute(
- NL80211_ATTR_IFINDEX, Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
- NetlinkMessage::MessageContext()));
+ NL80211_ATTR_IFINDEX,
+ base::Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
+ NetlinkMessage::MessageContext()));
}
const uint8_t TriggerScanMessage::kCommand = NL80211_CMD_TRIGGER_SCAN;
@@ -357,8 +365,9 @@
TriggerScanMessage::TriggerScanMessage()
: Nl80211Message(kCommand, kCommandString) {
attributes()->CreateAttribute(
- NL80211_ATTR_IFINDEX, Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
- NetlinkMessage::MessageContext()));
+ NL80211_ATTR_IFINDEX,
+ base::Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
+ NetlinkMessage::MessageContext()));
}
const uint8_t UnprotDeauthenticateMessage::kCommand =
@@ -378,15 +387,17 @@
WiphyRegChangeMessage::WiphyRegChangeMessage()
: Nl80211Message(kCommand, kCommandString) {
attributes()->CreateAttribute(
- NL80211_ATTR_IFINDEX, Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
- NetlinkMessage::MessageContext()));
+ NL80211_ATTR_IFINDEX,
+ base::Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
+ NetlinkMessage::MessageContext()));
}
GetInterfaceMessage::GetInterfaceMessage()
: Nl80211Message(kCommand, kCommandString) {
attributes()->CreateAttribute(
- NL80211_ATTR_IFINDEX, Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
- NetlinkMessage::MessageContext()));
+ NL80211_ATTR_IFINDEX,
+ base::Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
+ NetlinkMessage::MessageContext()));
}
const uint8_t GetInterfaceMessage::kCommand = NL80211_CMD_GET_INTERFACE;
@@ -401,8 +412,9 @@
GetSurveyMessage::GetSurveyMessage()
: Nl80211Message(kCommand, kCommandString) {
attributes()->CreateAttribute(
- NL80211_ATTR_IFINDEX, Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
- NetlinkMessage::MessageContext()));
+ NL80211_ATTR_IFINDEX,
+ base::Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
+ NetlinkMessage::MessageContext()));
AddFlag(NLM_F_DUMP);
}
@@ -416,11 +428,12 @@
GetMeshPathInfoMessage::GetMeshPathInfoMessage()
: Nl80211Message(kCommand, kCommandString) {
attributes()->CreateAttribute(
- NL80211_ATTR_IFINDEX, Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
- NetlinkMessage::MessageContext()));
+ NL80211_ATTR_IFINDEX,
+ base::Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
+ NetlinkMessage::MessageContext()));
attributes()->CreateAttribute(
- NL80211_ATTR_MAC, Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
- NetlinkMessage::MessageContext()));
+ NL80211_ATTR_MAC, base::Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
+ NetlinkMessage::MessageContext()));
}
const uint8_t GetMeshProxyPathMessage::kCommand = NL80211_CMD_GET_MPP;
@@ -429,11 +442,12 @@
GetMeshProxyPathMessage::GetMeshProxyPathMessage()
: Nl80211Message(kCommand, kCommandString) {
attributes()->CreateAttribute(
- NL80211_ATTR_IFINDEX, Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
- NetlinkMessage::MessageContext()));
+ NL80211_ATTR_IFINDEX,
+ base::Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
+ NetlinkMessage::MessageContext()));
attributes()->CreateAttribute(
- NL80211_ATTR_MAC, Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
- NetlinkMessage::MessageContext()));
+ NL80211_ATTR_MAC, base::Bind(&NetlinkAttribute::NewNl80211AttributeFromId,
+ NetlinkMessage::MessageContext()));
}
// static
diff --git a/shill/net/rtnl_handler.cc b/shill/net/rtnl_handler.cc
index b2999b5..fc336c9 100644
--- a/shill/net/rtnl_handler.cc
+++ b/shill/net/rtnl_handler.cc
@@ -32,14 +32,8 @@
#include "shill/net/ip_address.h"
#include "shill/net/ndisc.h"
#include "shill/net/netlink_fd.h"
-#include "shill/net/rtnl_listener.h"
-#include "shill/net/rtnl_message.h"
#include "shill/net/sockets.h"
-using base::Bind;
-using base::Unretained;
-using std::string;
-
namespace shill {
namespace Logging {
@@ -103,8 +97,8 @@
SetReceiverBufferSize(kReceiveBufferBytes);
rtnl_handler_.reset(io_handler_factory_->CreateIOInputHandler(
- rtnl_socket_, Bind(&RTNLHandler::ParseRTNL, Unretained(this)),
- Bind(&RTNLHandler::OnReadError, Unretained(this))));
+ rtnl_socket_, base::Bind(&RTNLHandler::ParseRTNL, base::Unretained(this)),
+ base::Bind(&RTNLHandler::OnReadError, base::Unretained(this))));
NextRequest(last_dump_sequence_);
SLOG(this, 2) << "RTNLHandler started";
@@ -441,7 +435,7 @@
return SendMessage(std::move(msg), nullptr);
}
-int RTNLHandler::GetInterfaceIndex(const string& interface_name) {
+int RTNLHandler::GetInterfaceIndex(const std::string& interface_name) {
if (interface_name.empty()) {
LOG(ERROR) << "Empty interface name -- unable to obtain index.";
return -1;
@@ -515,7 +509,7 @@
return true;
}
-void RTNLHandler::OnReadError(const string& error_msg) {
+void RTNLHandler::OnReadError(const std::string& error_msg) {
LOG(FATAL) << "RTNL Socket read returns error: " << error_msg;
}
diff --git a/shill/net/rtnl_handler_test.cc b/shill/net/rtnl_handler_test.cc
index 378db39..6264a80 100644
--- a/shill/net/rtnl_handler_test.cc
+++ b/shill/net/rtnl_handler_test.cc
@@ -24,10 +24,6 @@
#include "shill/net/mock_sockets.h"
#include "shill/net/rtnl_message.h"
-using base::Bind;
-using base::Callback;
-using base::Unretained;
-using std::string;
using testing::_;
using testing::A;
using testing::AtLeast;
@@ -67,7 +63,8 @@
public:
RTNLHandlerTest()
: sockets_(new StrictMock<MockSockets>()),
- callback_(Bind(&RTNLHandlerTest::HandlerCallback, Unretained(this))) {}
+ callback_(base::Bind(&RTNLHandlerTest::HandlerCallback,
+ base::Unretained(this))) {}
void SetUp() override {
RTNLHandler::GetInstance()->io_handler_factory_ = &io_handler_factory_;
@@ -141,7 +138,7 @@
MockSockets* sockets_;
StrictMock<MockIOHandlerFactory> io_handler_factory_;
- Callback<void(const RTNLMessage&)> callback_;
+ base::Callback<void(const RTNLMessage&)> callback_;
private:
base::test::TaskEnvironment task_environment_{
@@ -174,7 +171,7 @@
RTNLMessage message(RTNLMessage::kTypeLink, RTNLMessage::kModeAdd, 0, 0, 0,
kTestDeviceIndex, IPAddress::kFamilyIPv4);
message.SetAttribute(static_cast<uint16_t>(IFLA_IFNAME),
- ByteString(string(kTestDeviceName), true));
+ ByteString(std::string(kTestDeviceName), true));
ByteString b(message.Encode());
InputData data(b.GetData(), b.GetLength());
RTNLHandler::GetInstance()->ParseRTNL(&data);
@@ -227,7 +224,7 @@
EXPECT_EQ(-1, RTNLHandler::GetInstance()->GetInterfaceIndex(""));
{
struct ifreq ifr;
- string name(sizeof(ifr.ifr_name), 'x');
+ std::string name(sizeof(ifr.ifr_name), 'x');
EXPECT_EQ(-1, RTNLHandler::GetInstance()->GetInterfaceIndex(name));
}
diff --git a/shill/net/rtnl_listener.cc b/shill/net/rtnl_listener.cc
index 71ad42b..fef354e 100644
--- a/shill/net/rtnl_listener.cc
+++ b/shill/net/rtnl_listener.cc
@@ -6,17 +6,16 @@
#include "shill/net/rtnl_handler.h"
-using base::Callback;
-
namespace shill {
-RTNLListener::RTNLListener(int listen_flags,
- const Callback<void(const RTNLMessage&)>& callback)
+RTNLListener::RTNLListener(
+ int listen_flags, const base::Callback<void(const RTNLMessage&)>& callback)
: RTNLListener{listen_flags, callback, RTNLHandler::GetInstance()} {}
-RTNLListener::RTNLListener(int listen_flags,
- const Callback<void(const RTNLMessage&)>& callback,
- RTNLHandler* rtnl_handler)
+RTNLListener::RTNLListener(
+ int listen_flags,
+ const base::Callback<void(const RTNLMessage&)>& callback,
+ RTNLHandler* rtnl_handler)
: listen_flags_(listen_flags),
callback_(callback),
rtnl_handler_(rtnl_handler) {
diff --git a/shill/net/rtnl_message_test.cc b/shill/net/rtnl_message_test.cc
index 0dacc21..bdb42d2 100644
--- a/shill/net/rtnl_message_test.cc
+++ b/shill/net/rtnl_message_test.cc
@@ -18,7 +18,6 @@
#include "shill/net/byte_string.h"
#include "shill/net/ip_address.h"
-using std::string;
using testing::Test;
namespace shill {
@@ -716,10 +715,10 @@
RTNLMessage::kModeAdd, kNewLinkMessageWlan0InterfaceIndex,
kNewLinkMessageWlan0InterfaceFlags,
kNewLinkMessageWlan0InterfaceFlagsChange,
- ByteString(string(kNewLinkMessageWlan0MacAddress), false),
- string(kNewLinkMessageWlan0InterfaceName),
+ ByteString(std::string(kNewLinkMessageWlan0MacAddress), false),
+ std::string(kNewLinkMessageWlan0InterfaceName),
kNewLinkMessageWlan0MTU,
- ByteString(string(kNewLinkMessageWlan0Qdisc), true),
+ ByteString(std::string(kNewLinkMessageWlan0Qdisc), true),
kNewLinkMessageWlan0OperState);
}
@@ -732,7 +731,7 @@
EXPECT_EQ(RTNLMessage::kModeAdd, msg.mode());
EXPECT_EQ(kNewLinkMessageIbf1InterfaceIndex, msg.interface_index());
- ByteString name(string(kNewLinkMessageIbf1InterfaceName), true);
+ ByteString name(std::string(kNewLinkMessageIbf1InterfaceName), true);
EXPECT_TRUE(msg.HasAttribute(IFLA_IFNAME));
EXPECT_EQ(name.GetLength(), msg.GetAttribute(IFLA_IFNAME).GetLength());
EXPECT_TRUE(msg.GetAttribute(IFLA_IFNAME).Equals(name));
@@ -746,9 +745,10 @@
RTNLMessage::kModeDelete, kDelLinkMessageEth0InterfaceIndex,
kDelLinkMessageEth0InterfaceFlags,
kDelLinkMessageEth0InterfaceFlagsChange,
- ByteString(string(kDelLinkMessageEth0MacAddress), false),
- string(kDelLinkMessageEth0InterfacName), kDelLinkMessageEth0MTU,
- ByteString(string(kDelLinkMessageEth0Qdisc), true),
+ ByteString(std::string(kDelLinkMessageEth0MacAddress), false),
+ std::string(kDelLinkMessageEth0InterfacName),
+ kDelLinkMessageEth0MTU,
+ ByteString(std::string(kDelLinkMessageEth0Qdisc), true),
kDelLinkMessageEth0OperState);
}
diff --git a/shill/net/shill_time.cc b/shill/net/shill_time.cc
index e55eeb5..1196e85 100644
--- a/shill/net/shill_time.cc
+++ b/shill/net/shill_time.cc
@@ -4,14 +4,9 @@
#include "shill/net/shill_time.h"
-#include <string.h>
-#include <time.h>
-
#include <base/format_macros.h>
#include <base/strings/stringprintf.h>
-using std::string;
-
namespace shill {
Time::Time() {}
@@ -80,7 +75,7 @@
struct timeval now_boottime = {};
struct timeval now_wall_clock = {};
struct tm local_time = {};
- string wall_clock_string;
+ std::string wall_clock_string;
GetTimeMonotonic(&now_monotonic);
GetTimeBoottime(&now_boottime);
@@ -92,7 +87,7 @@
}
// static
-string Time::FormatTime(const struct tm& date_time, suseconds_t usec) {
+std::string Time::FormatTime(const struct tm& date_time, suseconds_t usec) {
char date_time_string[64];
size_t date_time_length;
date_time_length = strftime(date_time_string, sizeof(date_time_string),
@@ -100,7 +95,7 @@
// Stitch in the microseconds, to provider finer resolution than
// strftime allows.
- string full_string = "<unknown>";
+ std::string full_string = "<unknown>";
char* split_pos = static_cast<char*>(
memchr(date_time_string, ' ', sizeof(date_time_string)));
if (date_time_length && date_time_length < sizeof(date_time_string) &&
