Add an Ethernet EAP policy.

chrome/browser/ui/webui/options/preferences_browsertest.cc

 // Copyright (c) 2012 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 "chrome/browser/ui/webui/options/preferences_browsertest.h"
 
 #include <iostream>
 #include <sstream>
 
 #include "base/callback.h"
@@ skipping 212 matching lines @@
     const std::vector<base::Value*>& values) {
   for (size_t i = 0; i < names.size(); ++i)
     pref_service_->Set(names[i].c_str(), *values[i]);
 }
 
 void PreferencesBrowserTest::VerifyKeyValue(const base::DictionaryValue& dict,
                                             const std::string& key,
                                             const base::Value& expected) {
   const base::Value* actual = NULL;
   EXPECT_TRUE(dict.Get(key, &actual)) << "Was checking key: " << key;
-  EXPECT_EQ(expected, *actual) << "Was checking key: " << key;
+  if (actual)
+    EXPECT_EQ(expected, *actual) << "Was checking key: " << key;
 }
 
 void PreferencesBrowserTest::VerifyPref(const base::DictionaryValue* prefs,
                                         const std::string& name,
                                         const base::Value* value,
                                         const std::string& controlledBy,
                                         bool disabled,
                                         bool uncommitted) {
-  const base::Value* pref;
-  const base::DictionaryValue* dict;
+  const base::Value* pref = NULL;
+  const base::DictionaryValue* dict = NULL;
   ASSERT_TRUE(prefs->GetWithoutPathExpansion(name, &pref));
   ASSERT_TRUE(pref->GetAsDictionary(&dict));
   VerifyKeyValue(*dict, "value", *value);
-  if (!controlledBy.empty()) {
+  if (!controlledBy.empty())
     VerifyKeyValue(*dict, "controlledBy", base::StringValue(controlledBy));
-  } else {
+  else
     EXPECT_FALSE(dict->HasKey("controlledBy"));
-  }
+
   if (disabled)
     VerifyKeyValue(*dict, "disabled", base::FundamentalValue(true));
   else if (dict->HasKey("disabled"))
     VerifyKeyValue(*dict, "disabled", base::FundamentalValue(false));
+
   if (uncommitted)
     VerifyKeyValue(*dict, "uncommitted", base::FundamentalValue(true));
   else if (dict->HasKey("uncommitted"))
     VerifyKeyValue(*dict, "uncommitted", base::FundamentalValue(false));
 }
 
 void PreferencesBrowserTest::VerifyObservedPref(const std::string& json,
                                                 const std::string& name,
                                                 const base::Value* value,
                                                 const std::string& controlledBy,
@@ skipping 562 matching lines @@
 
   void VerifyCurrentProxyServer(const std::string& expected_server,
                                 chromeos::onc::ONCSource expected_source) {
     chromeos::onc::ONCSource actual_source;
     scoped_ptr<ProxyConfigDictionary> proxy_dict =
         chromeos::proxy_config::GetProxyConfigForNetwork(
             pref_service_,
             g_browser_process->local_state(),
             *GetDefaultNetwork(),
             &actual_source);
+    ASSERT_TRUE(proxy_dict);
     std::string actual_proxy_server;
     EXPECT_TRUE(proxy_dict->GetProxyServer(&actual_proxy_server));
     EXPECT_EQ(expected_server, actual_proxy_server);
     EXPECT_EQ(expected_source, actual_source);
   }
 };
 
 // Verifies that proxy settings are correctly pushed to JavaScript during
 // initialization of the proxy settings page.
 IN_PROC_BROWSER_TEST_F(ProxyPreferencesBrowserTest, ChromeOSInitializeProxy) {
@@ skipping 139 matching lines @@
   SetProxyPref(chromeos::kProxyHttpsPort, base::FundamentalValue(2));
   SetProxyPref(chromeos::kProxyFtpPort, base::FundamentalValue(3));
   SetProxyPref(chromeos::kProxySocksPort, base::FundamentalValue(4));
 
   VerifyCurrentProxyServer(
       "http=a.com:1;https=4.3.2.1:2;ftp=c.com:3;socks=socks4://d.com:4",
       chromeos::onc::ONC_SOURCE_NONE);
 }
 
 #endif