merge in nyc-release history after reset to master
diff --git a/Android.mk b/Android.mk
index 61850a6..601ba3e 100644
--- a/Android.mk
+++ b/Android.mk
@@ -40,6 +40,7 @@
brillo/type_name_undecorate.cc \
brillo/url_utils.cc \
brillo/userdb_utils.cc \
+ brillo/value_conversion.cc \
libbrillo_linux_sources := \
brillo/asynchronous_signal_handler.cc \
@@ -129,6 +130,7 @@
brillo/type_name_undecorate_unittest.cc \
brillo/unittest_utils.cc \
brillo/url_utils_unittest.cc \
+ brillo/value_conversion_unittest.cc \
libbrillo_dbus_test_sources := \
brillo/any_unittest.cc \
diff --git a/brillo/value_conversion.cc b/brillo/value_conversion.cc
new file mode 100644
index 0000000..aa5135b
--- /dev/null
+++ b/brillo/value_conversion.cc
@@ -0,0 +1,60 @@
+// Copyright 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <brillo/value_conversion.h>
+
+#include <string>
+#include <vector>
+
+namespace brillo {
+
+bool FromValue(const base::Value& in_value,
+ std::unique_ptr<base::ListValue>* out_value) {
+ const base::ListValue* list = nullptr;
+ if (!in_value.GetAsList(&list))
+ return false;
+ out_value->reset(list->DeepCopy());
+ return true;
+}
+
+bool FromValue(const base::Value& in_value,
+ std::unique_ptr<base::DictionaryValue>* out_value) {
+ const base::DictionaryValue* dict = nullptr;
+ if (!in_value.GetAsDictionary(&dict))
+ return false;
+ out_value->reset(dict->DeepCopy());
+ return true;
+}
+
+std::unique_ptr<base::Value> ToValue(int value) {
+ return std::unique_ptr<base::Value>{new base::FundamentalValue{value}};
+}
+
+std::unique_ptr<base::Value> ToValue(bool value) {
+ return std::unique_ptr<base::Value>{new base::FundamentalValue{value}};
+}
+
+std::unique_ptr<base::Value> ToValue(double value) {
+ return std::unique_ptr<base::Value>{new base::FundamentalValue{value}};
+}
+
+std::unique_ptr<base::Value> ToValue(const char* value) {
+ return std::unique_ptr<base::Value>{new base::StringValue{value}};
+}
+
+std::unique_ptr<base::Value> ToValue(const std::string& value) {
+ return std::unique_ptr<base::Value>{new base::StringValue{value}};
+}
+
+} // namespace brillo
diff --git a/brillo/value_conversion.h b/brillo/value_conversion.h
new file mode 100644
index 0000000..820fe75
--- /dev/null
+++ b/brillo/value_conversion.h
@@ -0,0 +1,139 @@
+// Copyright 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef BRILLO_VALUE_CONVERSION_H_
+#define BRILLO_VALUE_CONVERSION_H_
+
+// This file provides a set of helper functions to convert between base::Value
+// and native types. Apart from handling standard types such as 'int' and
+// 'std::string' it also provides conversion to/from std::vector<T> (which
+// converts to Base::listValue) and std::map<std::string, T> (convertible to
+// base::DictionaryValue).
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <base/values.h>
+#include <brillo/brillo_export.h>
+
+namespace brillo {
+
+inline bool FromValue(const base::Value& in_value, bool* out_value) {
+ return in_value.GetAsBoolean(out_value);
+}
+
+inline bool FromValue(const base::Value& in_value, int* out_value) {
+ return in_value.GetAsInteger(out_value);
+}
+
+inline bool FromValue(const base::Value& in_value, double* out_value) {
+ return in_value.GetAsDouble(out_value);
+}
+
+inline bool FromValue(const base::Value& in_value, std::string* out_value) {
+ return in_value.GetAsString(out_value);
+}
+
+inline bool FromValue(const base::Value& in_value,
+ const base::ListValue** out_value) {
+ return in_value.GetAsList(out_value);
+}
+
+inline bool FromValue(const base::Value& in_value,
+ const base::DictionaryValue** out_value) {
+ return in_value.GetAsDictionary(out_value);
+}
+
+BRILLO_EXPORT bool FromValue(const base::Value& in_value,
+ std::unique_ptr<base::ListValue>* out_value);
+BRILLO_EXPORT bool FromValue(const base::Value& in_value,
+ std::unique_ptr<base::DictionaryValue>* out_value);
+
+template <typename T, typename Pred, typename Alloc>
+bool FromValue(const base::Value& in_value,
+ std::map<std::string, T, Pred, Alloc>* out_value);
+
+template <typename T, typename Alloc>
+bool FromValue(const base::Value& in_value, std::vector<T, Alloc>* out_value) {
+ const base::ListValue* list = nullptr;
+ if (!in_value.GetAsList(&list))
+ return false;
+ out_value->clear();
+ out_value->reserve(list->GetSize());
+ for (const base::Value* item : *list) {
+ T value{};
+ if (!FromValue(*item, &value))
+ return false;
+ out_value->push_back(std::move(value));
+ }
+ return true;
+}
+
+template <typename T, typename Pred, typename Alloc>
+bool FromValue(const base::Value& in_value,
+ std::map<std::string, T, Pred, Alloc>* out_value) {
+ const base::DictionaryValue* dict = nullptr;
+ if (!in_value.GetAsDictionary(&dict))
+ return false;
+ out_value->clear();
+ for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
+ if (!FromValue(it.value(), &(*out_value)[it.key()]))
+ return false;
+ }
+ return true;
+}
+
+template <typename T>
+T FromValue(const base::Value& value) {
+ T out_value{};
+ CHECK(FromValue(value, &out_value));
+ return out_value;
+}
+
+BRILLO_EXPORT std::unique_ptr<base::Value> ToValue(int value);
+BRILLO_EXPORT std::unique_ptr<base::Value> ToValue(bool value);
+BRILLO_EXPORT std::unique_ptr<base::Value> ToValue(double value);
+BRILLO_EXPORT std::unique_ptr<base::Value> ToValue(const std::string& value);
+// Implicit conversion of char* to 'bool' has precedence over the user-defined
+// std::string conversion. Override this behavior explicitly.
+BRILLO_EXPORT std::unique_ptr<base::Value> ToValue(const char* value);
+
+template <typename T, typename Pred, typename Alloc>
+std::unique_ptr<base::Value> ToValue(
+ const std::map<std::string, T, Pred, Alloc>& dictionary);
+
+template <typename T, typename Alloc>
+std::unique_ptr<base::Value> ToValue(const std::vector<T, Alloc>& list) {
+ std::unique_ptr<base::ListValue> result{new base::ListValue};
+ for (const auto& value : list) {
+ result->Append(ToValue(value).release());
+ }
+ return std::move(result);
+}
+
+template <typename T, typename Pred, typename Alloc>
+std::unique_ptr<base::Value> ToValue(
+ const std::map<std::string, T, Pred, Alloc>& dictionary) {
+ std::unique_ptr<base::DictionaryValue> result{new base::DictionaryValue};
+ for (const auto& pair : dictionary) {
+ result->Set(pair.first, ToValue(pair.second).release());
+ }
+ return std::move(result);
+}
+
+} // namespace brillo
+
+#endif // BRILLO_VALUE_CONVERSION_H_
diff --git a/brillo/value_conversion_unittest.cc b/brillo/value_conversion_unittest.cc
new file mode 100644
index 0000000..cf2afb7
--- /dev/null
+++ b/brillo/value_conversion_unittest.cc
@@ -0,0 +1,266 @@
+// Copyright 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <brillo/value_conversion.h>
+
+#include <limits>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <base/json/json_reader.h>
+#include <base/json/json_writer.h>
+#include <gtest/gtest.h>
+
+namespace brillo {
+
+namespace {
+
+std::unique_ptr<base::Value> ParseValue(std::string json) {
+ std::replace(json.begin(), json.end(), '\'', '"');
+ std::string message;
+ std::unique_ptr<base::Value> value{
+ base::JSONReader::ReadAndReturnError(json, base::JSON_PARSE_RFC,nullptr,
+ &message)
+ .release()};
+ CHECK(value) << "Failed to load JSON: " << message << ", " << json;
+ return value;
+}
+
+inline bool IsEqualValue(const base::Value& val1, const base::Value& val2) {
+ return val1.Equals(&val2);
+}
+
+#define EXPECT_JSON_EQ(expected, actual) \
+ EXPECT_PRED2(IsEqualValue, *ParseValue(expected), actual)
+
+} // namespace
+
+TEST(ValueConversionTest, FromValueInt) {
+ int actual;
+ EXPECT_TRUE(FromValue(*ParseValue("123"), &actual));
+ EXPECT_EQ(123, actual);
+
+ EXPECT_TRUE(FromValue(*ParseValue("-123"), &actual));
+ EXPECT_EQ(-123, actual);
+
+ EXPECT_FALSE(FromValue(*ParseValue("true"), &actual));
+}
+
+TEST(ValueConversionTest, FromValueBool) {
+ bool actual;
+ EXPECT_TRUE(FromValue(*ParseValue("false"), &actual));
+ EXPECT_FALSE(actual);
+
+ EXPECT_TRUE(FromValue(*ParseValue("true"), &actual));
+ EXPECT_TRUE(actual);
+
+ EXPECT_FALSE(FromValue(*ParseValue("0"), &actual));
+ EXPECT_FALSE(FromValue(*ParseValue("1"), &actual));
+}
+
+TEST(ValueConversionTest, FromValueDouble) {
+ double actual;
+ EXPECT_TRUE(FromValue(*ParseValue("12.5"), &actual));
+ EXPECT_DOUBLE_EQ(12.5, actual);
+
+ EXPECT_TRUE(FromValue(*ParseValue("-0.1"), &actual));
+ EXPECT_DOUBLE_EQ(-0.1, actual);
+
+ EXPECT_TRUE(FromValue(*ParseValue("17"), &actual));
+ EXPECT_DOUBLE_EQ(17.0, actual);
+
+ EXPECT_FALSE(FromValue(*ParseValue("'1.0'"), &actual));
+}
+
+TEST(ValueConversionTest, FromValueString) {
+ std::string actual;
+ EXPECT_TRUE(FromValue(*ParseValue("'foo'"), &actual));
+ EXPECT_EQ("foo", actual);
+
+ EXPECT_TRUE(FromValue(*ParseValue("'bar'"), &actual));
+ EXPECT_EQ("bar", actual);
+
+ EXPECT_TRUE(FromValue(*ParseValue("''"), &actual));
+ EXPECT_TRUE(actual.empty());
+
+ EXPECT_FALSE(FromValue(*ParseValue("1"), &actual));
+}
+
+TEST(ValueConversionTest, FromValueListValue) {
+ const base::ListValue* list = nullptr;
+ auto in_value = ParseValue("[1, 2, 'foo']");
+ EXPECT_TRUE(FromValue(*in_value, &list));
+ EXPECT_JSON_EQ("[1, 2, 'foo']", *list);
+}
+
+TEST(ValueConversionTest, FromValueDictValue) {
+ const base::DictionaryValue* dict = nullptr;
+ auto in_value = ParseValue("{'foo':'bar','baz': 1}");
+ EXPECT_TRUE(FromValue(*in_value, &dict));
+ EXPECT_JSON_EQ("{'foo':'bar','baz': 1}", *dict);
+}
+
+TEST(ValueConversionTest, FromValueListValueUniquePtr) {
+ std::unique_ptr<base::ListValue> list;
+ EXPECT_TRUE(FromValue(*ParseValue("[1, 2, 'bar']"), &list));
+ EXPECT_JSON_EQ("[1, 2, 'bar']", *list);
+}
+
+TEST(ValueConversionTest, FromValueDictValueUniquePtr) {
+ std::unique_ptr<base::DictionaryValue> dict;
+ EXPECT_TRUE(FromValue(*ParseValue("{'foo':'bar','baz': 1}"), &dict));
+ EXPECT_JSON_EQ("{'foo':'bar','baz': 1}", *dict);
+}
+
+TEST(ValueConversionTest, FromValueVectorOfInt) {
+ std::vector<int> actual;
+ EXPECT_TRUE(FromValue(*ParseValue("[1, 2, 3, 4]"), &actual));
+ EXPECT_EQ((std::vector<int>{1, 2, 3, 4}), actual);
+
+ EXPECT_TRUE(FromValue(*ParseValue("[]"), &actual));
+ EXPECT_TRUE(actual.empty());
+
+ EXPECT_FALSE(FromValue(*ParseValue("[1, 2, 3, '4']"), &actual));
+}
+
+TEST(ValueConversionTest, FromValueVectorOfBool) {
+ std::vector<bool> actual;
+ EXPECT_TRUE(FromValue(*ParseValue("[true, true, false]"), &actual));
+ EXPECT_EQ((std::vector<bool>{true, true, false}), actual);
+
+ EXPECT_TRUE(FromValue(*ParseValue("[]"), &actual));
+ EXPECT_TRUE(actual.empty());
+
+ EXPECT_FALSE(FromValue(*ParseValue("[true, 0]"), &actual));
+}
+
+TEST(ValueConversionTest, FromValueVectorOfDouble) {
+ std::vector<double> actual;
+ EXPECT_TRUE(FromValue(*ParseValue("[1, 2.0, 6.5, -11.2]"), &actual));
+ EXPECT_EQ((std::vector<double>{1.0, 2.0, 6.5, -11.2}), actual);
+
+ EXPECT_TRUE(FromValue(*ParseValue("[]"), &actual));
+ EXPECT_TRUE(actual.empty());
+
+ EXPECT_FALSE(FromValue(*ParseValue("['s']"), &actual));
+}
+
+TEST(ValueConversionTest, FromValueVectorOfString) {
+ std::vector<std::string> actual;
+ EXPECT_TRUE(FromValue(*ParseValue("['', 'foo', 'bar']"), &actual));
+ EXPECT_EQ((std::vector<std::string>{"", "foo", "bar"}), actual);
+
+ EXPECT_TRUE(FromValue(*ParseValue("[]"), &actual));
+ EXPECT_TRUE(actual.empty());
+
+ EXPECT_FALSE(FromValue(*ParseValue("[100]"), &actual));
+}
+
+TEST(ValueConversionTest, FromValueVectorOfVectors) {
+ std::vector<std::vector<int>> actual;
+ EXPECT_TRUE(FromValue(*ParseValue("[[1,2], [], [3]]"), &actual));
+ EXPECT_EQ((std::vector<std::vector<int>>{{1,2}, {}, {3}}), actual);
+
+ EXPECT_TRUE(FromValue(*ParseValue("[]"), &actual));
+ EXPECT_TRUE(actual.empty());
+
+ EXPECT_FALSE(FromValue(*ParseValue("[100]"), &actual));
+}
+
+TEST(ValueConversionTest, FromValueMap) {
+ std::map<std::string, int> actual;
+ EXPECT_TRUE(FromValue(*ParseValue("{'foo':1, 'bar':2, 'baz':3}"), &actual));
+ EXPECT_EQ((std::map<std::string, int>{{"foo", 1}, {"bar", 2}, {"baz", 3}}),
+ actual);
+
+ EXPECT_TRUE(FromValue(*ParseValue("{}"), &actual));
+ EXPECT_TRUE(actual.empty());
+
+ EXPECT_FALSE(FromValue(*ParseValue("{'foo':1, 'bar':'2'}"), &actual));
+}
+
+TEST(ValueConversionTest, FromValueMapOfVectors) {
+ std::map<std::string, std::vector<int>> actual;
+ EXPECT_TRUE(FromValue(*ParseValue("{'foo':[1,2], 'bar':[]}"), &actual));
+ std::map<std::string, std::vector<int>> expected{
+ {"foo", {1, 2}}, {"bar", {}}};
+ EXPECT_EQ(expected, actual);
+
+ EXPECT_TRUE(FromValue(*ParseValue("{}"), &actual));
+ EXPECT_TRUE(actual.empty());
+
+ EXPECT_FALSE(FromValue(*ParseValue("{'foo':[1], 'bar':[2,'3']}"), &actual));
+}
+
+TEST(ValueConversionTest, FromValueVectorOfMaps) {
+ std::vector<std::map<std::string, int>> actual;
+ EXPECT_TRUE(FromValue(*ParseValue("[{'foo':1,'bar':2},{'baz':3}]"), &actual));
+ std::vector<std::map<std::string, int>> expected{
+ {{"foo", 1}, {"bar", 2}}, {{"baz", 3}}};
+ EXPECT_EQ(expected, actual);
+
+ EXPECT_TRUE(FromValue(*ParseValue("[]"), &actual));
+ EXPECT_TRUE(actual.empty());
+
+ EXPECT_FALSE(FromValue(*ParseValue("[{'foo':1}, 'bar']"), &actual));
+}
+
+TEST(ValueConversionTest, FromValueVectorOfLists) {
+ std::vector<std::unique_ptr<base::ListValue>> actual;
+ EXPECT_TRUE(FromValue(*ParseValue("[['foo',1],['bar',2],[true]]"), &actual));
+ ASSERT_EQ(3, actual.size());
+ EXPECT_JSON_EQ("['foo', 1]", *actual[0]);
+ EXPECT_JSON_EQ("['bar', 2]", *actual[1]);
+ EXPECT_JSON_EQ("[true]", *actual[2]);
+}
+
+TEST(ValueConversionTest, FromValueVectorOfDicts) {
+ std::vector<std::unique_ptr<base::DictionaryValue>> actual;
+ EXPECT_TRUE(FromValue(*ParseValue("[{'foo': 1}, {'bar': 2}]"), &actual));
+ ASSERT_EQ(2, actual.size());
+ EXPECT_JSON_EQ("{'foo': 1}", *actual[0]);
+ EXPECT_JSON_EQ("{'bar': 2}", *actual[1]);
+}
+
+TEST(ValueConversionTest, ToValueScalar) {
+ EXPECT_JSON_EQ("1234", *ToValue(1234));
+ EXPECT_JSON_EQ("true", *ToValue(true));
+ EXPECT_JSON_EQ("false", *ToValue(false));
+ EXPECT_JSON_EQ("12.5", *ToValue(12.5));
+ EXPECT_JSON_EQ("'foobar'", *ToValue("foobar"));
+}
+
+TEST(ValueConversionTest, ToValueVector) {
+ EXPECT_JSON_EQ("[1, 2, 3]", *ToValue(std::vector<int>{1, 2, 3}));
+ EXPECT_JSON_EQ("[]", *ToValue(std::vector<int>{}));
+ EXPECT_JSON_EQ("[true, false]", *ToValue(std::vector<bool>{true, false}));
+ EXPECT_JSON_EQ("['foo', 'bar']",
+ *ToValue(std::vector<std::string>{"foo", "bar"}));
+ EXPECT_JSON_EQ("[[1,2],[3]]",
+ *ToValue(std::vector<std::vector<int>>{{1, 2}, {3}}));
+}
+
+TEST(ValueConversionTest, ToValueMap) {
+ EXPECT_JSON_EQ("{'foo': 1, 'bar': 2}",
+ *ToValue(std::map<std::string, int>{{"foo", 1}, {"bar", 2}}));
+ EXPECT_JSON_EQ("{}", *ToValue(std::map<std::string, int>{}));
+ EXPECT_JSON_EQ("{'foo': true}",
+ *ToValue(std::map<std::string, bool>{{"foo", true}}));
+ EXPECT_JSON_EQ("{'foo': 1.1, 'bar': 2.2}",
+ *ToValue(std::map<std::string, double>{{"foo", 1.1},
+ {"bar", 2.2}}));
+}
+
+} // namespace brillo
diff --git a/libbrillo.gypi b/libbrillo.gypi
index f2d7882..2b5027b 100644
--- a/libbrillo.gypi
+++ b/libbrillo.gypi
@@ -89,6 +89,7 @@
'brillo/type_name_undecorate.cc',
'brillo/url_utils.cc',
'brillo/userdb_utils.cc',
+ 'brillo/value_conversion.cc',
],
},
{
@@ -360,6 +361,7 @@
'brillo/unittest_utils.cc',
'brillo/url_utils_unittest.cc',
'brillo/variant_dictionary_unittest.cc',
+ 'brillo/value_conversion_unittest.cc',
'testrunner.cc',
'<(proto_in_dir)/test.proto',
]
diff --git a/policy/device_policy.h b/policy/device_policy.h
index 7a60a65..34e7a64 100644
--- a/policy/device_policy.h
+++ b/policy/device_policy.h
@@ -83,22 +83,6 @@
virtual bool GetEphemeralUsersEnabled(
bool* ephemeral_users_enabled) const = 0;
- // Writes the value of the ProxyMode policy in |proxy_mode|. Returns true on
- // success.
- virtual bool GetProxyMode(std::string* proxy_mode) const = 0;
-
- // Writes the value of the ProxyServer policy in |proxy_server|. Returns true
- // on success.
- virtual bool GetProxyServer(std::string* proxy_server) const = 0;
-
- // Writes the value of the ProxyPacUrl policy in |proxy_pac|. Returns true on
- // success.
- virtual bool GetProxyPacUrl(std::string* proxy_pac) const = 0;
-
- // Writes the value of the ProxyBypassList policy in |proxy_bypass_list|.
- // Returns true on success.
- virtual bool GetProxyBypassList(std::string* proxy_bypass_list) const = 0;
-
// Writes the value of the release channel policy in |release_channel|.
// Returns true on success.
virtual bool GetReleaseChannel(std::string* release_channel) const = 0;
diff --git a/policy/device_policy_impl.cc b/policy/device_policy_impl.cc
index 7d9bc60..565fb62 100644
--- a/policy/device_policy_impl.cc
+++ b/policy/device_policy_impl.cc
@@ -246,59 +246,6 @@
return true;
}
-bool DevicePolicyImpl::GetProxyMode(std::string* proxy_mode) const {
- if (!device_policy_.has_device_proxy_settings())
- return false;
-
- const enterprise_management::DeviceProxySettingsProto& proto =
- device_policy_.device_proxy_settings();
- if (!proto.has_proxy_mode())
- return false;
-
- *proxy_mode = proto.proxy_mode();
- return true;
-}
-
-bool DevicePolicyImpl::GetProxyServer(std::string* proxy_server) const {
- if (!device_policy_.has_device_proxy_settings())
- return false;
-
- const enterprise_management::DeviceProxySettingsProto& proto =
- device_policy_.device_proxy_settings();
- if (!proto.has_proxy_server())
- return false;
-
- *proxy_server = proto.proxy_server();
- return true;
-}
-
-bool DevicePolicyImpl::GetProxyPacUrl(std::string* proxy_pac) const {
- if (!device_policy_.has_device_proxy_settings())
- return false;
-
- const enterprise_management::DeviceProxySettingsProto& proto =
- device_policy_.device_proxy_settings();
- if (!proto.has_proxy_pac_url())
- return false;
-
- *proxy_pac = proto.proxy_pac_url();
- return true;
-}
-
-bool DevicePolicyImpl::GetProxyBypassList(
- std::string* proxy_bypass_list) const {
- if (!device_policy_.has_device_proxy_settings())
- return false;
-
- const enterprise_management::DeviceProxySettingsProto& proto =
- device_policy_.device_proxy_settings();
- if (!proto.has_proxy_bypass_list())
- return false;
-
- *proxy_bypass_list = proto.proxy_bypass_list();
- return true;
-}
-
bool DevicePolicyImpl::GetReleaseChannel(
std::string* release_channel) const {
if (!device_policy_.has_release_channel())
diff --git a/policy/device_policy_impl.h b/policy/device_policy_impl.h
index 7174ce1..7733469 100644
--- a/policy/device_policy_impl.h
+++ b/policy/device_policy_impl.h
@@ -43,10 +43,6 @@
virtual bool GetReportActivityTimes(bool* report_activity_times) const;
virtual bool GetReportBootMode(bool* report_boot_mode) const;
virtual bool GetEphemeralUsersEnabled(bool* ephemeral_users_enabled) const;
- virtual bool GetProxyMode(std::string* proxy_mode) const;
- virtual bool GetProxyServer(std::string* proxy_server) const;
- virtual bool GetProxyPacUrl(std::string* proxy_pac) const;
- virtual bool GetProxyBypassList(std::string* proxy_bypass_list) const;
virtual bool GetReleaseChannel(std::string* release_channel) const;
virtual bool GetReleaseChannelDelegated(
bool* release_channel_delegated) const;
diff --git a/policy/mock_device_policy.h b/policy/mock_device_policy.h
index bd53787..0986bb6 100644
--- a/policy/mock_device_policy.h
+++ b/policy/mock_device_policy.h
@@ -76,10 +76,6 @@
bool(bool*)); // NOLINT(readability/function)
MOCK_CONST_METHOD1(GetEphemeralUsersEnabled,
bool(bool*)); // NOLINT(readability/function)
- MOCK_CONST_METHOD1(GetProxyMode, bool(std::string*));
- MOCK_CONST_METHOD1(GetProxyServer, bool(std::string*));
- MOCK_CONST_METHOD1(GetProxyPacUrl, bool(std::string*));
- MOCK_CONST_METHOD1(GetProxyBypassList, bool(std::string*));
MOCK_CONST_METHOD1(GetReleaseChannel, bool(std::string*));
MOCK_CONST_METHOD1(GetReleaseChannelDelegated,
bool(bool*)); // NOLINT(readability/function)
diff --git a/policy/tests/libpolicy_unittest.cc b/policy/tests/libpolicy_unittest.cc
index 45475b5..02e800d 100644
--- a/policy/tests/libpolicy_unittest.cc
+++ b/policy/tests/libpolicy_unittest.cc
@@ -111,19 +111,6 @@
ASSERT_TRUE(policy.GetEphemeralUsersEnabled(&bool_value));
ASSERT_FALSE(bool_value);
- std::string string_value;
- ASSERT_TRUE(policy.GetProxyMode(&string_value));
- ASSERT_EQ("direct", string_value);
-
- ASSERT_TRUE(policy.GetProxyServer(&string_value));
- ASSERT_EQ("myproxy", string_value);
-
- ASSERT_TRUE(policy.GetProxyPacUrl(&string_value));
- ASSERT_EQ("http://mypac.pac", string_value);
-
- ASSERT_TRUE(policy.GetProxyBypassList(&string_value));
- ASSERT_EQ("a, b, c", string_value);
-
ASSERT_TRUE(policy.GetReleaseChannel(&string_value));
ASSERT_EQ("stable-channel", string_value);
