Add getGlobalPolicy to networkingPrivate API.

chrome/browser/extensions/api/networking_private/networking_private_apitest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
 #include <utility>
 #include <vector>
@@ skipping 165 matching lines @@
       return result;
     result.reset(new DeviceStateList);
     std::unique_ptr<api::networking_private::DeviceStateProperties> properties(
         new api::networking_private::DeviceStateProperties);
     properties->type = api::networking_private::NETWORK_TYPE_ETHERNET;
     properties->state = api::networking_private::DEVICE_STATE_TYPE_ENABLED;
     result->push_back(std::move(properties));
     return result;
   }
 
+  std::unique_ptr<base::DictionaryValue> GetGlobalPolicy() override {
+    auto result = base::MakeUnique<base::DictionaryValue>();
+    result->SetBooleanWithoutPathExpansion(

[tbarzic, 2017/01/06 22:43:17]

I'd add an extra property to the policy dict - to ensure API handles that case
well.

[stevenjb, 2017/01/09 19:30:37]

Good call, but I will actually do that in the chromeos specific test. I am going
to make this just return an empty dictionary and remove the trivial api test for
consistency. We should really either make the rest of these delegate methods
trivial, or get assertEq working and actually test the return values for the
entire API.

+        onc::global_network_config::kAllowOnlyPolicyNetworksToAutoconnect,
+        true);
+    result->SetBooleanWithoutPathExpansion(
+        onc::global_network_config::kAllowOnlyPolicyNetworksToConnect, false);
+    return result;
+  }
+
   bool EnableNetworkType(const std::string& type) override {
     enabled_[type] = true;
     return !fail_;
   }
 
   bool DisableNetworkType(const std::string& type) override {
     disabled_[type] = true;
     return !fail_;
   }
 
@@ skipping 259 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, UnlockCellularSim) {
   EXPECT_TRUE(RunNetworkingSubtest("unlockCellularSim")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, SetCellularSimState) {
   EXPECT_TRUE(RunNetworkingSubtest("setCellularSimState")) << message_;
 }
 
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, GetGlobalPolicy) {
+  EXPECT_TRUE(RunNetworkingSubtest("getGlobalPolicy")) << message_;
+}
+
 // Test failure case
 
 class NetworkingPrivateApiTestFail : public NetworkingPrivateApiTest {
  public:
   NetworkingPrivateApiTestFail() { s_test_delegate_->set_fail(true); }
 
  protected:
   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateApiTestFail);
 };
 
@@ skipping 34 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, GetDeviceStates) {
   EXPECT_FALSE(RunNetworkingSubtest("getDeviceStates")) << message_;
 }
 
 // Note: Synchronous methods never fail:
 // * disableNetworkType
 // * enableNetworkType
 // * requestNetworkScan
+// * getGlobalPolicy
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, StartConnect) {
   EXPECT_FALSE(RunNetworkingSubtest("startConnect")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, StartDisconnect) {
   EXPECT_FALSE(RunNetworkingSubtest("startDisconnect")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, StartActivate) {
@@ skipping 29 matching lines @@
   EXPECT_FALSE(RunNetworkingSubtest("unlockCellularSim")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, SetCellularSimState) {
   EXPECT_FALSE(RunNetworkingSubtest("setCellularSimState")) << message_;
 }
 
 #endif // defined(OS_WIN)
 
 }  // namespace extensions