Replace misc. network stub flags with more flexible ones

chromeos/dbus/fake_shill_service_client.cc

 // Copyright 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/fake_shill_service_client.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
-#include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
-#include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/dbus/shill_property_changed_observer.h"
-#include "chromeos/dbus/shill_stub_helper.h"
 #include "chromeos/network/shill_property_util.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 void PassStubListValue(const ShillServiceClient::ListValueCallback& callback,
                        base::ListValue* value) {
   callback.Run(*value);
 }
 
 void PassStubServiceProperties(
     const ShillServiceClient::DictionaryValueCallback& callback,
     DBusMethodCallStatus call_status,
     const base::DictionaryValue* properties) {
   callback.Run(call_status, *properties);
 }
 
+int GetInteractiveDelay() {
+  return DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
+      GetInteractiveDelay();
+}
+
 }  // namespace
 
 FakeShillServiceClient::FakeShillServiceClient() : weak_ptr_factory_(this) {
 }
 
 FakeShillServiceClient::~FakeShillServiceClient() {
   STLDeleteContainerPairSecondPointers(
       observer_list_.begin(), observer_list_.end());
 }
 
 
 // ShillServiceClient overrides.
 
 void FakeShillServiceClient::Init(dbus::Bus* bus) {
+  // Note: FakeShillManagerClient sets up default services before this is
+  // called.
 }
 
 void FakeShillServiceClient::AddPropertyChangedObserver(
     const dbus::ObjectPath& service_path,
     ShillPropertyChangedObserver* observer) {
   GetObserverList(service_path).AddObserver(observer);
 }
 
 void FakeShillServiceClient::RemovePropertyChangedObserver(
     const dbus::ObjectPath& service_path,
@@ skipping 115 matching lines @@
   // sending an update.
   SetOtherServicesOffline(service_path.value());
 
   // Set Associating.
   base::StringValue associating_value(shill::kStateAssociation);
   SetServiceProperty(service_path.value(),
                      shill::kStateProperty,
                      associating_value);
 
   // Stay Associating until the state is changed again after a delay.
-  base::TimeDelta delay;
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          chromeos::switches::kEnableStubInteractive)) {
-    const int kConnectDelaySeconds = 5;
-    delay = base::TimeDelta::FromSeconds(kConnectDelaySeconds);
-  }
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FakeShillServiceClient::ContinueConnect,
                  weak_ptr_factory_.GetWeakPtr(),
                  service_path.value()),
-      delay);
+      base::TimeDelta::FromSeconds(GetInteractiveDelay()));
 
   callback.Run();
 }
 
 void FakeShillServiceClient::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
   base::StringValue idle_value(shill::kStateIdle);
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FakeShillServiceClient::SetProperty,
                  weak_ptr_factory_.GetWeakPtr(),
                  service_path,
                  shill::kStateProperty,
                  idle_value,
                  base::Bind(&base::DoNothing),
                  error_callback),
-      delay);
+      base::TimeDelta::FromSeconds(GetInteractiveDelay()));
   callback.Run();
 }
 
 void FakeShillServiceClient::Remove(const dbus::ObjectPath& service_path,
                                     const base::Closure& callback,
                                     const ErrorCallback& error_callback) {
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 void FakeShillServiceClient::ActivateCellularModem(
     const dbus::ObjectPath& service_path,
     const std::string& carrier,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   base::DictionaryValue* service_properties =
       GetModifiableServiceProperties(service_path.value(), false);
   if (!service_properties) {
     LOG(ERROR) << "Service not found: " << service_path.value();
     error_callback.Run("Error.InvalidService", "Invalid Service");
   }
   SetServiceProperty(service_path.value(),
                      shill::kActivationStateProperty,
                      base::StringValue(shill::kActivationStateActivating));
-  base::TimeDelta delay;
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          chromeos::switches::kEnableStubInteractive)) {
-    const int kConnectDelaySeconds = 2;
-    delay = base::TimeDelta::FromSeconds(kConnectDelaySeconds);
-  }
   // Set Activated after a delay
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FakeShillServiceClient::SetCellularActivated,
                  weak_ptr_factory_.GetWeakPtr(),
                  service_path,
                  error_callback),
-      delay);
+      base::TimeDelta::FromSeconds(GetInteractiveDelay()));
 
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 void FakeShillServiceClient::CompleteCellularActivation(
     const dbus::ObjectPath& service_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
@@ skipping 32 matching lines @@
 }
 
 // ShillServiceClient::TestInterface overrides.
 
 void FakeShillServiceClient::AddService(const std::string& service_path,
                                         const std::string& name,
                                         const std::string& type,
                                         const std::string& state,
                                         bool add_to_visible_list,
                                         bool add_to_watch_list) {
-  std::string nstate = state;
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          chromeos::switches::kDefaultStubNetworkStateIdle)) {
-    nstate = shill::kStateIdle;
-  }
-  AddServiceWithIPConfig(service_path, name, type, nstate, "",
+  AddServiceWithIPConfig(service_path, name, type, state, "",
                          add_to_visible_list, add_to_watch_list);
 }
 
 void FakeShillServiceClient::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_visible_list,
     bool add_to_watch_list) {
   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
       AddManagerService(service_path, add_to_visible_list, add_to_watch_list);
+  ShillDeviceClient::TestInterface* device_client =
+      DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface();
 
   base::DictionaryValue* properties =
       GetModifiableServiceProperties(service_path, true);
   connect_behavior_.erase(service_path);
   shill_property_util::SetSSID(name, properties);
   properties->SetWithoutPathExpansion(
       shill::kNameProperty,
       base::Value::CreateStringValue(name));
   properties->SetWithoutPathExpansion(
       shill::kDeviceProperty,
       base::Value::CreateStringValue(
-          shill_stub_helper::DevicePathForType(type)));
+          device_client->GetDevicePathForType(type)));
   properties->SetWithoutPathExpansion(
       shill::kTypeProperty,
       base::Value::CreateStringValue(type));
   properties->SetWithoutPathExpansion(
       shill::kStateProperty,
       base::Value::CreateStringValue(state));
   if (!ipconfig_path.empty())
     properties->SetWithoutPathExpansion(
         shill::kIPConfigProperty,
         base::Value::CreateStringValue(ipconfig_path));
@@ skipping 193 matching lines @@
             base::StringValue(shill::kErrorBadPassphrase)));
   } else {
     // Set Online.
     SetServiceProperty(service_path,
                        shill::kStateProperty,
                        base::StringValue(shill::kStateOnline));
   }
 }
 
 }  // namespace chromeos