This factors out all of the parsing code from the network library

chrome/browser/automation/testing_automation_provider_chromeos.cc

 // Copyright (c) 2011 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/automation/testing_automation_provider.h"
 
 #include "base/i18n/time_formatting.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
@@ skipping 131 matching lines @@
                          const char* error_msg) {
   AutomationJSONReply* reply = static_cast<AutomationJSONReply*>(user_data);
   if (result == chromeos::UPDATE_RESULT_SUCCESS)
     reply->SendSuccess(NULL);
   else
     reply->SendError(error_msg);
   delete reply;
 }
 
 const std::string VPNProviderTypeToString(
-    chromeos::VirtualNetwork::ProviderType provider_type) {
+    chromeos::ProviderType provider_type) {
   switch (provider_type) {
-    case chromeos::VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK:
+    case chromeos::PROVIDER_TYPE_L2TP_IPSEC_PSK:
       return std::string("L2TP_IPSEC_PSK");
-    case chromeos::VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT:
+    case chromeos::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT:
       return std::string("L2TP_IPSEC_USER_CERT");
-    case chromeos::VirtualNetwork::PROVIDER_TYPE_OPEN_VPN:
+    case chromeos::PROVIDER_TYPE_OPEN_VPN:
       return std::string("OPEN_VPN");
     default:
       return std::string("UNSUPPORTED_PROVIDER_TYPE");
   }
 }
 
 const char* EnterpriseStatusToString(
     policy::CloudPolicySubsystem::PolicySubsystemState state) {
   switch (state) {
     case policy::CloudPolicySubsystem::UNENROLLED:
@@ skipping 537 matching lines @@
       !args->GetString("password", &password)) {
     AutomationJSONReply(this, reply_message)
         .SendError("Invalid or missing args.");
     return;
   }
 
   NetworkLibrary* network_library = CrosLibrary::Get()->GetNetworkLibrary();
 
   // Attempt to connect to the VPN based on the provider type.
   if (provider_type == VPNProviderTypeToString(
-      chromeos::VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK)) {
+      chromeos::PROVIDER_TYPE_L2TP_IPSEC_PSK)) {
     if (!args->GetString("key", &key)) {
       AutomationJSONReply(this, reply_message)
           .SendError("Missing key arg.");
       return;
     }
     new VirtualConnectObserver(this, reply_message, service_name);
     // Connect using a pre-shared key.
     network_library->ConnectToVirtualNetworkPSK(service_name,
                                                 hostname,
                                                 key,
                                                 username,
                                                 password);
   } else if (provider_type == VPNProviderTypeToString(
-      chromeos::VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT)) {
+      chromeos::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT)) {
     if (!args->GetString("cert_id", &cert_id) ||
         !args->GetString("cert_nss", &cert_nss)) {
       AutomationJSONReply(this, reply_message)
           .SendError("Missing a certificate arg.");
       return;
     }
     new VirtualConnectObserver(this, reply_message, service_name);
     // Connect using a user certificate.
     network_library->ConnectToVirtualNetworkCert(service_name,
                                                  hostname,
                                                  cert_nss,
                                                  cert_id,
                                                  username,
                                                  password);
   } else if (provider_type == VPNProviderTypeToString(
-      chromeos::VirtualNetwork::PROVIDER_TYPE_OPEN_VPN)) {
+      chromeos::PROVIDER_TYPE_OPEN_VPN)) {
     // Connect using OPEN_VPN. Not yet supported by the VPN implementation.
     AutomationJSONReply(this, reply_message)
       .SendError("Provider type OPEN_VPN is not yet supported.");
     return;
   } else {
     AutomationJSONReply(this, reply_message)
         .SendError("Unsupported provider type.");
     return;
   }
 }
@@ skipping 343 matching lines @@
 
   // Set up an observer (it will delete itself).
   take_photo_dialog->AddObserver(new PhotoCaptureObserver(
       this, reply_message));
 
   views::Widget* window = browser::CreateViewsWindow(
       browser->window()->GetNativeHandle(), take_photo_dialog);
   window->SetAlwaysOnTop(true);
   window->Show();
 }