Add NetworkHandler to own network handlers in src/chromeos/network

chromeos/network/managed_network_configuration_handler.cc

 // Copyright (c) 2013 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 "chromeos/network/managed_network_configuration_handler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 298 matching lines @@
     const base::DictionaryValue& shill_properties) {
   scoped_ptr<base::DictionaryValue> onc_network(
       onc::TranslateShillServiceToONCPart(
           shill_properties,
           &onc::kNetworkWithStateSignature));
   callback.Run(service_path, *onc_network);
 }
 
 }  // namespace
 
-static ManagedNetworkConfigurationHandler*
-g_configuration_handler_instance = NULL;
-
-// static
-void ManagedNetworkConfigurationHandler::Initialize(
-    NetworkProfileHandler* profile_handler) {
-  CHECK(!g_configuration_handler_instance);
-  g_configuration_handler_instance =
-      new ManagedNetworkConfigurationHandler(profile_handler);
-}
-
-// static
-bool ManagedNetworkConfigurationHandler::IsInitialized() {
-  return g_configuration_handler_instance;
-}
-
-// static
-void ManagedNetworkConfigurationHandler::Shutdown() {
-  CHECK(g_configuration_handler_instance);
-  delete g_configuration_handler_instance;
-  g_configuration_handler_instance = NULL;
-}
-
-// static
-ManagedNetworkConfigurationHandler* ManagedNetworkConfigurationHandler::Get() {
-  CHECK(g_configuration_handler_instance);
-  return g_configuration_handler_instance;
-}
-
 void ManagedNetworkConfigurationHandler::GetManagedProperties(
     const std::string& userhash,
     const std::string& service_path,
     const network_handler::DictionaryResultCallback& callback,
     const network_handler::ErrorCallback& error_callback) {
   if (!GetPoliciesForUser(userhash) || !GetPoliciesForUser(std::string())) {
     RunErrorCallback(service_path,
                      kPoliciesNotInitialized,
                      kPoliciesNotInitializedMessage,
                      error_callback);
     return;
   }
-  NetworkConfigurationHandler::Get()->GetProperties(
+  NetworkHandler::Get()->network_configuration_handler()->GetProperties(
       service_path,
       base::Bind(
           &ManagedNetworkConfigurationHandler::GetManagedPropertiesCallback,
           weak_ptr_factory_.GetWeakPtr(),
           callback,
           error_callback),
       error_callback);
 }
 
 void ManagedNetworkConfigurationHandler::GetManagedPropertiesCallback(
     const network_handler::DictionaryResultCallback& callback,
     const network_handler::ErrorCallback& error_callback,
     const std::string& service_path,
     const base::DictionaryValue& shill_properties) {
   std::string profile_path;
   shill_properties.GetStringWithoutPathExpansion(flimflam::kProfileProperty,
                                                  &profile_path);
-  const NetworkProfile* profile =
-      profile_handler_->GetProfileForPath(profile_path);
+  const NetworkProfile* profile = NetworkHandler::Get()->
+      network_profile_handler()->GetProfileForPath(profile_path);
   if (!profile) {
     VLOG(1) << "No or no known profile received for service "
             << service_path << ".";
   }
 
   scoped_ptr<NetworkUIData> ui_data = GetUIData(shill_properties);
 
   const base::DictionaryValue* user_settings = NULL;
   const base::DictionaryValue* shared_settings = NULL;
 
@@ skipping 50 matching lines @@
           user_settings,
           shared_settings,
           active_settings.get());
   callback.Run(service_path, *augmented_properties);
 }
 
 void ManagedNetworkConfigurationHandler::GetProperties(
     const std::string& service_path,
     const network_handler::DictionaryResultCallback& callback,
     const network_handler::ErrorCallback& error_callback) const {
-  NetworkConfigurationHandler::Get()->GetProperties(
+  NetworkHandler::Get()->network_configuration_handler()->GetProperties(
       service_path,
       base::Bind(&TranslatePropertiesToOncAndRunCallback, callback),
       error_callback);
 }
 
 void ManagedNetworkConfigurationHandler::SetProperties(
     const std::string& service_path,
     const base::DictionaryValue& user_settings,
     const base::Closure& callback,
     const network_handler::ErrorCallback& error_callback) const {
-  const NetworkState* state =
-      NetworkStateHandler::Get()->GetNetworkState(service_path);
+  const NetworkState* state = NetworkHandler::Get()->network_state_handler()->
+      GetNetworkState(service_path);
 
   if (!state) {
     RunErrorCallback(service_path,
                      kUnknownServicePath,
                      kUnknownServicePathMessage,
                      error_callback);
     return;
   }
 
   std::string guid = state->guid();
   if (guid.empty()) {
     // TODO(pneubeck): create an initial configuration in this case. As for
     // CreateConfiguration, user settings from older ChromeOS versions have to
     // determined here.
     RunErrorCallback(service_path,
                      kSetOnUnconfiguredNetwork,
                      kSetOnUnconfiguredNetworkMessage,
                      error_callback);
     return;
   }
 
   const std::string& profile_path = state->profile_path();
-  const NetworkProfile *profile =
-      profile_handler_->GetProfileForPath(profile_path);
+  const NetworkProfile *profile = NetworkHandler::Get()->
+      network_profile_handler()->GetProfileForPath(profile_path);
   if (!profile) {
     RunErrorCallback(service_path,
                      kUnknownProfilePath,
                      kUnknownProfilePathMessage,
                      error_callback);
     return;
   }
 
   VLOG(2) << "SetProperties: Found GUID " << guid << " and profile "
           << profile->ToDebugString();
@@ skipping 30 matching lines @@
   }
   if (validation_result == onc::Validator::VALID_WITH_WARNINGS)
     LOG(WARNING) << "Validation of ONC user settings produced warnings.";
 
   const base::DictionaryValue* policy = GetByGUID(*policies, guid);
   VLOG(2) << "This configuration is " << (policy ? "" : "not ") << "managed.";
 
   scoped_ptr<base::DictionaryValue> shill_dictionary(
       CreateShillConfiguration(*profile, guid, policy, &user_settings));
 
-  NetworkConfigurationHandler::Get()->SetProperties(service_path,
-                                                    *shill_dictionary,
-                                                    callback,
-                                                    error_callback);
+  NetworkHandler::Get()->network_configuration_handler()->SetProperties(
+      service_path, *shill_dictionary, callback, error_callback);
 }
 
 void ManagedNetworkConfigurationHandler::Connect(
     const std::string& service_path,
     const base::Closure& callback,
     const network_handler::ErrorCallback& error_callback) const {
-  NetworkConfigurationHandler::Get()->Connect(service_path,
-                                              callback,
-                                              error_callback);
+  NetworkHandler::Get()->network_configuration_handler()->Connect(
+      service_path, callback, error_callback);
 }
 
 void ManagedNetworkConfigurationHandler::Disconnect(
     const std::string& service_path,
     const base::Closure& callback,
     const network_handler::ErrorCallback& error_callback) const {
-  NetworkConfigurationHandler::Get()->Disconnect(service_path,
-                                                 callback,
-                                                 error_callback);
+  NetworkHandler::Get()->network_configuration_handler()->Disconnect(
+      service_path, callback, error_callback);
 }
 
 void ManagedNetworkConfigurationHandler::CreateConfiguration(
     const std::string& userhash,
     const base::DictionaryValue& properties,
     const network_handler::StringResultCallback& callback,
     const network_handler::ErrorCallback& error_callback) const {
   const GuidToPolicyMap* policies = GetPoliciesForUser(userhash);
   if (!policies) {
     RunErrorCallback("",
                      kPoliciesNotInitialized,
                      kPoliciesNotInitializedMessage,
                      error_callback);
     return;
   }
 
   if (FindMatchingPolicy(*policies, properties)) {
     RunErrorCallback("",
                      kNetworkAlreadyConfigured,
                      kNetworkAlreadyConfiguredMessage,
                      error_callback);
   }
 
-  const NetworkProfile* profile =
-      profile_handler_->GetProfileForUserhash(userhash);
+  const NetworkProfile* profile = NetworkHandler::Get()->
+      network_profile_handler()->GetProfileForUserhash(userhash);
   if (!profile) {
     RunErrorCallback("",
                      kProfileNotInitialized,
                      kProfileNotInitializedMessage,
                      error_callback);
   }
 
   // TODO(pneubeck): In case of WiFi, check that no other configuration for the
   // same {SSID, mode, security} exists. We don't support such multiple
   // configurations, yet.
 
   // Generate a new GUID for this configuration. Ignore the maybe provided GUID
   // in |properties| as it is not our own and from an untrusted source.
   std::string guid = base::GenerateGUID();
   scoped_ptr<base::DictionaryValue> shill_dictionary(
       CreateShillConfiguration(*profile, guid, NULL /*no policy*/,
                                &properties));
 
-  NetworkConfigurationHandler::Get()->CreateConfiguration(*shill_dictionary,
-                                                          callback,
-                                                          error_callback);
+  NetworkHandler::Get()->network_configuration_handler()->CreateConfiguration(
+      *shill_dictionary, callback, error_callback);
 }
 
 void ManagedNetworkConfigurationHandler::RemoveConfiguration(
     const std::string& service_path,
     const base::Closure& callback,
     const network_handler::ErrorCallback& error_callback) const {
-  NetworkConfigurationHandler::Get()->RemoveConfiguration(service_path,
-                                                          callback,
-                                                          error_callback);
+  NetworkHandler::Get()->network_configuration_handler()->RemoveConfiguration(
+      service_path, callback, error_callback);
 }
 
 // This class compares (entry point is Run()) |modified_policies| with the
 // existing entries in the provided Shill profile |profile|. It fetches all
 // entries in parallel (GetProfileProperties), compares each entry with the
 // current policies (GetEntry) and adds all missing policies
 // (~PolicyApplicator).
 class ManagedNetworkConfigurationHandler::PolicyApplicator
     : public base::RefCounted<PolicyApplicator> {
  public:
@@ skipping 126 matching lines @@
       } else {
         VLOG_IF(1, old_guid == new_guid)
             << "Updating previously managed configuration with the updated "
             << "policy " << new_guid << ".";
 
         // Update the existing configuration with the maybe changed
         // policy. Thereby the GUID might change.
         scoped_ptr<base::DictionaryValue> shill_dictionary =
             CreateShillConfiguration(profile_, new_guid, new_policy,
                                      ui_data->user_settings());
-        NetworkConfigurationHandler::Get()->CreateConfiguration(
-            *shill_dictionary,
-            base::Bind(&IgnoreString),
-            base::Bind(&LogErrorWithDict, FROM_HERE));
+        NetworkHandler::Get()->network_configuration_handler()->
+            CreateConfiguration(*shill_dictionary,
+                                base::Bind(&IgnoreString),
+                                base::Bind(&LogErrorWithDict, FROM_HERE));
         remaining_policies_.erase(new_guid);
       }
     } else if (was_managed) {
       VLOG(1) << "Removing configuration previously managed by policy "
               << old_guid << ", because the policy was removed.";
 
       // Remove the entry, because the network was managed but isn't anymore.
       // Note: An alternative might be to preserve the user settings, but it's
       // unclear which values originating the policy should be removed.
       DeleteEntry(entry);
@@ skipping 41 matching lines @@
         LOG(ERROR) << "Policy " << *it << " doesn't exist anymore.";
         continue;
       }
 
       VLOG(1) << "Creating new configuration managed by policy " << *it
               << " in profile " << profile_.ToDebugString() << ".";
 
       scoped_ptr<base::DictionaryValue> shill_dictionary =
           CreateShillConfiguration(profile_, *it, policy,
                                    NULL /* no user settings */);
-      NetworkConfigurationHandler::Get()->CreateConfiguration(
-          *shill_dictionary,
-          base::Bind(&IgnoreString),
-          base::Bind(&LogErrorWithDict, FROM_HERE));
+      NetworkHandler::Get()->network_configuration_handler()->
+          CreateConfiguration(*shill_dictionary,
+                              base::Bind(&IgnoreString),
+                              base::Bind(&LogErrorWithDict, FROM_HERE));
     }
   }
 
   std::set<std::string> remaining_policies_;
   base::WeakPtr<ManagedNetworkConfigurationHandler> handler_;
   NetworkProfile profile_;
 
   DISALLOW_COPY_AND_ASSIGN(PolicyApplicator);
 };
 
@@ skipping 34 matching lines @@
     const base::DictionaryValue* new_entry = network->DeepCopy();
     policies[guid] = new_entry;
 
     const base::DictionaryValue* old_entry = old_policies[guid];
     if (!old_entry || !old_entry->Equals(new_entry))
       modified_policies.insert(guid);
   }
 
   STLDeleteValues(&old_policies);
 
-  const NetworkProfile* profile =
-      profile_handler_->GetProfileForUserhash(userhash);
+  const NetworkProfile* profile = NetworkHandler::Get()->
+      network_profile_handler()->GetProfileForUserhash(userhash);
   if (!profile) {
     VLOG(1) << "The relevant Shill profile isn't initialized yet, postponing "
             << "policy application.";
     return;
   }
 
   scoped_refptr<PolicyApplicator> applicator = new PolicyApplicator(
       weak_ptr_factory_.GetWeakPtr(),
       *profile,
       &modified_policies);
@@ skipping 39 matching lines @@
 }
 
 const ManagedNetworkConfigurationHandler::GuidToPolicyMap*
 ManagedNetworkConfigurationHandler::GetPoliciesForProfile(
     const NetworkProfile& profile) const {
   DCHECK(profile.type() != NetworkProfile::TYPE_SHARED ||
          profile.userhash.empty());
   return GetPoliciesForUser(profile.userhash);
 }
 
-ManagedNetworkConfigurationHandler::ManagedNetworkConfigurationHandler(
-    NetworkProfileHandler* profile_handler)
-    : profile_handler_(profile_handler),
-      weak_ptr_factory_(this) {
-  profile_handler_->AddObserver(this);
+ManagedNetworkConfigurationHandler::ManagedNetworkConfigurationHandler()
+    : weak_ptr_factory_(this) {
 }
 
 ManagedNetworkConfigurationHandler::~ManagedNetworkConfigurationHandler() {
-  profile_handler_->RemoveObserver(this);
+  NetworkHandler::Get()->network_profile_handler()->RemoveObserver(this);
   for (UserToPoliciesMap::iterator it = policies_by_user_.begin();
        it != policies_by_user_.end(); ++it) {
     STLDeleteValues(&it->second);
   }
 }
 
+void ManagedNetworkConfigurationHandler::Init() {
+  NetworkHandler::Get()->network_profile_handler()->AddObserver(this);
+}
+
 }  // namespace chromeos