Added stub portalled wifi network.

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/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_manager_client.h"
 #include "chromeos/dbus/shill_profile_client_stub.h"
 #include "chromeos/dbus/shill_property_changed_observer.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_proxy.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
+const char kStubPortalledWifiPath[] = "portalled_wifi";
+const char kStubPortalledWifiName[] = "Portalled Wifi";
+
 void ErrorFunction(const std::string& error_name,
                    const std::string& error_message) {
   LOG(ERROR) << "Shill Error: " << error_name << " : " << error_message;
 }
 
 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);
 }
 
 }  // namespace
 
 ShillServiceClientStub::ShillServiceClientStub() : weak_ptr_factory_(this) {
 }
 
 ShillServiceClientStub::~ShillServiceClientStub() {
   STLDeleteContainerPairSecondPointers(
       observer_list_.begin(), observer_list_.end());
 }
 
+// static
+bool ShillServiceClientStub::IsStubPortalledWifiEnabled(
+    const std::string& path) {
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(
+          chromeos::switches::kEnableStubPortalledWifi)) {
+    return false;
+  }
+  return path == kStubPortalledWifiPath;
+}
+
 // ShillServiceClient overrides.
 
 void ShillServiceClientStub::AddPropertyChangedObserver(
     const dbus::ObjectPath& service_path,
     ShillPropertyChangedObserver* observer) {
   GetObserverList(service_path).AddObserver(observer);
 }
 
 void ShillServiceClientStub::RemovePropertyChangedObserver(
     const dbus::ObjectPath& service_path,
@@ skipping 121 matching lines @@
                      associating_value);
 
   // Set Online after a delay.
   base::TimeDelta delay;
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kEnableStubInteractive)) {
     const int kConnectDelaySeconds = 5;
     delay = base::TimeDelta::FromSeconds(kConnectDelaySeconds);
   }
   base::StringValue online_value(flimflam::kStateOnline);
+  if (service_path.value() == kStubPortalledWifiPath)
+    online_value = base::StringValue(flimflam::kStatePortal);
   std::string passphrase;
   service_properties->GetStringWithoutPathExpansion(
       flimflam::kPassphraseProperty, &passphrase);
   if (passphrase == "failure")
     online_value = base::StringValue(flimflam::kStateFailure);
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ShillServiceClientStub::SetProperty,
                  weak_ptr_factory_.GetWeakPtr(),
                  service_path,
@@ skipping 108 matching lines @@
 }
 
 // ShillServiceClient::TestInterface overrides.
 
 void ShillServiceClientStub::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) {
-  AddServiceWithIPConfig(service_path, name, type, state, "",
+  std::string nstate = state;
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          chromeos::switches::kDefaultStubNetworkStateIdle)) {
+    nstate = flimflam::kStateIdle;
+  }
+  AddServiceWithIPConfig(service_path, name, type, nstate, "",
                          add_to_visible_list, add_to_watch_list);
 }
 
 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_visible_list,
@@ skipping 113 matching lines @@
              flimflam::kStateIdle,
              add_to_visible, add_to_watchlist);
   SetServiceProperty("wifi2",
                      flimflam::kSecurityProperty,
                      base::StringValue(flimflam::kSecurityPsk));
   base::FundamentalValue strength_value(80);
   SetServiceProperty("wifi2",
                      flimflam::kSignalStrengthProperty,
                      strength_value);
 
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          chromeos::switches::kEnableStubPortalledWifi)) {
+    AddService(kStubPortalledWifiPath, kStubPortalledWifiName,
+               flimflam::kTypeWifi,
+               flimflam::kStatePortal,
+               add_to_visible, add_to_watchlist);
+    SetServiceProperty(kStubPortalledWifiPath,
+                       flimflam::kSecurityProperty,
+                       base::StringValue(flimflam::kSecurityNone));
+  }
+
   // Wimax
 
   AddService("wimax1", "wimax1",
              flimflam::kTypeWimax,
              flimflam::kStateIdle,
              add_to_visible, add_to_watchlist);
   SetServiceProperty("wimax1",
                      flimflam::kConnectableProperty,
                      base::FundamentalValue(true));
 
@@ skipping 114 matching lines @@
     properties->GetString(flimflam::kTypeProperty, &type);
     if (type != service_type)
       continue;
     properties->SetWithoutPathExpansion(
         flimflam::kStateProperty,
         base::Value::CreateStringValue(flimflam::kStateIdle));
   }
 }
 
 }  // namespace chromeos