Add NetworkConnectionHandler class

chromeos/dbus/shill_service_client_stub.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/dbus/shill_service_client_stub.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 94 matching lines @@
     error_callback.Run("Error.InvalidService", "Invalid Service");
     return;
   }
   if (name == flimflam::kStateProperty) {
     // If we connect to a service, then we move it to the top of the list in
     // the manager client.
     std::string state;
     if (value.GetAsString(&state) && state == flimflam::kStateOnline) {
       ShillManagerClient* manager_client =
           DBusThreadManager::Get()->GetShillManagerClient();
-      manager_client->GetTestInterface()->RemoveService(service_path.value());
-      manager_client->GetTestInterface()->AddServiceAtIndex(
+      manager_client->GetTestInterface()->MoveServiceToIndex(
           service_path.value(), 0, true);
     }
   }
   dict->SetWithoutPathExpansion(name, value.DeepCopy());
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&ShillServiceClientStub::NotifyObserversPropertyChanged,
                  weak_ptr_factory_.GetWeakPtr(), service_path, name));
   if (callback.is_null())
     return;
@@ skipping 55 matching lines @@
 }
 
 void ShillServiceClientStub::Connect(const dbus::ObjectPath& service_path,
                                      const base::Closure& callback,
                                      const ErrorCallback& error_callback) {
   base::Value* service;
   if (!stub_services_.Get(service_path.value(), &service)) {
     error_callback.Run("Error.InvalidService", "Invalid Service");
     return;
   }
-  // Set Associating
-  base::StringValue associating_value(flimflam::kStateAssociation);
-  SetServiceProperty(service_path.value(),
-                     flimflam::kStateProperty,
-                     associating_value);
+  base::TimeDelta delay;
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          chromeos::switches::kEnableStubInteractive)) {
+    // Set Associating
+    base::StringValue associating_value(flimflam::kStateAssociation);
+    SetServiceProperty(service_path.value(),
+                       flimflam::kStateProperty,
+                       associating_value);
+    const int kConnectDelaySeconds = 5;
+    delay = base::TimeDelta::FromSeconds(kConnectDelaySeconds);
+  }
   // Set Online after a delay
-  const int kConnectDelaySeconds = 5;
   base::StringValue online_value(flimflam::kStateOnline);
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ShillServiceClientStub::SetProperty,
                  weak_ptr_factory_.GetWeakPtr(),
                  service_path,
                  flimflam::kStateProperty,
                  online_value,
                  base::Bind(&base::DoNothing),
                  error_callback),
-                 base::TimeDelta::FromSeconds(kConnectDelaySeconds));
+      delay);
   callback.Run();
 }
 
 void ShillServiceClientStub::Disconnect(const dbus::ObjectPath& service_path,
                                         const base::Closure& callback,
                                         const ErrorCallback& error_callback) {
   base::Value* service;
   if (!stub_services_.Get(service_path.value(), &service)) {
     error_callback.Run("Error.InvalidService", "Invalid Service");
     return;
   }
+  base::TimeDelta delay;
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          chromeos::switches::kEnableStubInteractive)) {
+    const int kConnectDelaySeconds = 2;
+    delay = base::TimeDelta::FromSeconds(kConnectDelaySeconds);
+  }
   // Set Idle after a delay
-  const int kConnectDelaySeconds = 2;
   base::StringValue idle_value(flimflam::kStateIdle);
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ShillServiceClientStub::SetProperty,
                  weak_ptr_factory_.GetWeakPtr(),
                  service_path,
                  flimflam::kStateProperty,
                  idle_value,
                  base::Bind(&base::DoNothing),
                  error_callback),
-                 base::TimeDelta::FromSeconds(kConnectDelaySeconds));
+      delay);
   callback.Run();
 }
 
 void ShillServiceClientStub::Remove(const dbus::ObjectPath& service_path,
                                     const base::Closure& callback,
                                     const ErrorCallback& error_callback) {
   if (callback.is_null())
     return;
   MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
@@ skipping 39 matching lines @@
 }
 
 void ShillServiceClientStub::AddServiceWithIPConfig(
     const std::string& service_path,
     const std::string& name,
     const std::string& type,
     const std::string& state,
     const std::string& ipconfig_path,
     bool add_to_watch_list) {
   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
-      AddService(service_path, add_to_watch_list);
+      AddManagerService(service_path, add_to_watch_list);
 
   base::DictionaryValue* properties =
       GetModifiableServiceProperties(service_path);
   properties->SetWithoutPathExpansion(
       flimflam::kSSIDProperty,
       base::Value::CreateStringValue(service_path));
   properties->SetWithoutPathExpansion(
       flimflam::kNameProperty,
       base::Value::CreateStringValue(name));
   properties->SetWithoutPathExpansion(
       flimflam::kTypeProperty,
       base::Value::CreateStringValue(type));
   properties->SetWithoutPathExpansion(
       flimflam::kStateProperty,
       base::Value::CreateStringValue(state));
   if (!ipconfig_path.empty())
     properties->SetWithoutPathExpansion(
         shill::kIPConfigProperty,
         base::Value::CreateStringValue(ipconfig_path));
 }
 
 void ShillServiceClientStub::RemoveService(const std::string& service_path) {
   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
-      RemoveService(service_path);
+      RemoveManagerService(service_path);
 
   stub_services_.RemoveWithoutPathExpansion(service_path, NULL);
 }
 
 void ShillServiceClientStub::SetServiceProperty(const std::string& service_path,
                                                 const std::string& property,
                                                 const base::Value& value) {
   SetProperty(dbus::ObjectPath(service_path), property, value,
               base::Bind(&base::DoNothing),
               base::Bind(&ErrorFunction));
 }
 
 const base::DictionaryValue* ShillServiceClientStub::GetServiceProperties(
     const std::string& service_path) const {
   const base::DictionaryValue* properties = NULL;
   stub_services_.GetDictionaryWithoutPathExpansion(service_path, &properties);
   return properties;
 }
 
 void ShillServiceClientStub::ClearServices() {
   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
-      ClearServices();
+      ClearManagerServices();
 
   stub_services_.Clear();
 }
 
 void ShillServiceClientStub::SetDefaultProperties() {
   const bool add_to_watchlist = true;
 
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kDisableStubEthernet)) {
     AddService("stub_ethernet", "eth0",
@@ skipping 84 matching lines @@
   std::map<dbus::ObjectPath, PropertyObserverList*>::iterator iter =
       observer_list_.find(device_path);
   if (iter != observer_list_.end())
     return *(iter->second);
   PropertyObserverList* observer_list = new PropertyObserverList();
   observer_list_[device_path] = observer_list;
   return *observer_list;
 }
 
 }  // namespace chromeos