Show notifications for Network Config errors

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"
@@ skipping 147 matching lines @@
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&PassStubListValue,
                  callback, base::Owned(results.release())));
 }
 
 void ShillServiceClientStub::Connect(const dbus::ObjectPath& service_path,
                                      const base::Closure& callback,
                                      const ErrorCallback& error_callback) {
   VLOG(1) << "ShillServiceClientStub::Connect: " << service_path.value();
-  base::Value* service;
-  if (!stub_services_.Get(service_path.value(), &service)) {
+  base::DictionaryValue* service_properties;
+  if (!stub_services_.GetDictionary(
+          service_path.value(), &service_properties)) {
     LOG(ERROR) << "Service not found: " << service_path.value();
     error_callback.Run("Error.InvalidService", "Invalid Service");
     return;
   }
 
   // Set any other services of the same Type to 'offline' first, before setting
   // State to Association which will trigger sorting Manager.Services and
   // sending an update.
   SetOtherServicesOffline(service_path.value());
 
   // Set Associating.
   base::StringValue associating_value(flimflam::kStateAssociation);
   SetServiceProperty(service_path.value(),
                      flimflam::kStateProperty,
                      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);
+  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,
                  flimflam::kStateProperty,
                  online_value,
                  base::Bind(&base::DoNothing),
                  error_callback),
       delay);
   callback.Run();
+  // On failure, also set the Error property.
+  if (passphrase == "failure") {
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&ShillServiceClientStub::SetProperty,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   service_path,
+                   flimflam::kErrorProperty,
+                   base::StringValue(flimflam::kErrorBadPassphrase),
+                   base::Bind(&base::DoNothing),
+                   error_callback),
+        delay);
+  }
 }
 
 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;
   }
@@ skipping 347 matching lines @@
     properties->GetString(flimflam::kTypeProperty, &type);
     if (type != service_type)
       continue;
     properties->SetWithoutPathExpansion(
         flimflam::kStateProperty,
         base::Value::CreateStringValue(flimflam::kStateIdle));
   }
 }
 
 }  // namespace chromeos