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 278 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;
-}
 
 // static
 scoped_ptr<NetworkUIData> ManagedNetworkConfigurationHandler::GetUIData(
     const base::DictionaryValue& shill_dictionary) {
   std::string ui_data_blob;
   if (shill_dictionary.GetStringWithoutPathExpansion(
           flimflam::kUIDataProperty,
           &ui_data_blob) &&
       !ui_data_blob.empty()) {
     scoped_ptr<base::DictionaryValue> ui_data_dict =
@@ skipping 12 matching lines @@
     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(
+  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);
+      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(
+  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);
+      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);
+      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);
+  network_configuration_handler_->SetProperties(
+      service_path, *shill_dictionary, 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);
+      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);
+  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);
+  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));
+        handler_->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(
+      handler_->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_;
 
@@ skipping 38 matching lines @@
     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);
+      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),
+ManagedNetworkConfigurationHandler::ManagedNetworkConfigurationHandler()
+    : network_state_handler_(NULL),
+      network_profile_handler_(NULL),
+      network_configuration_handler_(NULL),
       weak_ptr_factory_(this) {
-  profile_handler_->AddObserver(this);
 }
 
 ManagedNetworkConfigurationHandler::~ManagedNetworkConfigurationHandler() {
-  profile_handler_->RemoveObserver(this);
+  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(
+    NetworkStateHandler* network_state_handler,
+    NetworkProfileHandler* network_profile_handler,
+    NetworkConfigurationHandler* network_configuration_handler) {
+  network_state_handler_ = network_state_handler;
+  network_profile_handler_ = network_profile_handler;
+  network_configuration_handler_ = network_configuration_handler;
+  network_profile_handler_->AddObserver(this);
+}
+
 }  // namespace chromeos