[login_manager] Code to add the owner to the whitelist in a device policy

session_manager_service.cc

 // Copyright (c) 2011 The Chromium OS 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 "login_manager/session_manager_service.h"
 
 #include <dbus/dbus-glib-lowlevel.h>
 #include <errno.h>
 #include <glib.h>
 #include <grp.h>
@@ skipping 31 matching lines @@
 #include "login_manager/owner_key.h"
 
 // Forcibly namespace the dbus-bindings generated server bindings instead of
 // modifying the files afterward.
 namespace login_manager {  // NOLINT
 namespace gobject {  // NOLINT
 #include "login_manager/bindings/server.h"
 }  // namespace gobject
 }  // namespace login_manager
 
+namespace em = enterprise_management;
 namespace login_manager {
 
 using std::make_pair;
 using std::pair;
 using std::string;
 using std::vector;
 
 // Jacked from chrome base/eintr_wrapper.h
 #define HANDLE_EINTR(x) ({ \
   typeof(x) __eintr_result__; \
@@ skipping 409 matching lines @@
   return FALSE;
 }
 
 gboolean SessionManagerService::StartSession(gchar* email_address,
                                              gchar* unique_identifier,
                                              gboolean* OUT_done,
                                              GError** error) {
   if (session_started_) {
     const char msg[] = "Can't start session while session is already active.";
     LOG(ERROR) << msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_SESSION_EXISTS, msg);
+    system_->SetGError(error, CHROMEOS_LOGIN_ERROR_SESSION_EXISTS, msg);
     return *OUT_done = FALSE;
   }
   if (!ValidateAndCacheUserEmail(email_address, error)) {
     *OUT_done = FALSE;
     return FALSE;
   }
   // If the current user is the owner, and isn't whitelisted or set
-  // as the cros.device.owner pref, then do so.  This attempt only succeeds
-  // if the current user has access to the private half of the owner's
-  // registered public key.
-  StoreOwnerProperties(NULL);
+  // as the cros.device.owner pref, then do so.
+  bool can_access_key = CurrentUserHasOwnerKey(key_->public_key_der(), error);
+  if (can_access_key)
+    StoreOwnerProperties(NULL);
   // Now, the flip side...if we believe the current user to be the owner
   // based on the cros.owner.device setting, and he DOESN'T have the private
   // half of the public key, we must mitigate.
-  if (CurrentUserIsOwner(error) &&
-      !CurrentUserHasOwnerKey(key_->public_key_der(), error)) {
+  if (CurrentUserIsOwner() && !can_access_key) {
     if (!(*OUT_done = mitigator_->Mitigate()))
       return FALSE;
   }
 
   *OUT_done =
       upstart_signal_emitter_->EmitSignal(
           "start-user-session",
           StringPrintf("CHROMEOS_USER=%s", current_user_.c_str()),
           error);
 
@@ skipping 95 matching lines @@
   //                the session manager
   // child_job_->StopSession();
   // session_started_ = false;
   return *OUT_done = TRUE;
 }
 
 gboolean SessionManagerService::SetOwnerKey(GArray* public_key_der,
                                             GError** error) {
   const char msg[] = "The session_manager now sets the Owner's public key.";
   LOG(ERROR) << msg;
-  SetGError(error, CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY, msg);
+  system_->SetGError(error, CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY, msg);
   // Just to be safe, send back a nACK in addition to returning an error.
   SendSignal(chromium::kOwnerKeySetSignal, false);
   return FALSE;
 }
 
 gboolean SessionManagerService::Unwhitelist(gchar* email_address,
                                             GArray* signature,
                                             GError** error) {
   LOG(INFO) << "Unwhitelisting " << email_address;
   SessionManagerService::SigReturnCode verify_result =
       VerifyHelperArray(email_address, signature);
   if (verify_result == NO_KEY) {
     const char msg[] = "Attempt to unwhitelist before owner's key is set.";
     LOG(ERROR) << msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_NO_OWNER_KEY, msg);
+    system_->SetGError(error, CHROMEOS_LOGIN_ERROR_NO_OWNER_KEY, msg);
     return FALSE;
   } else if (verify_result == SIGNATURE_FAIL) {
     const char msg[] = "Signature could not be verified in Unwhitelist.";
     LOG(ERROR) << msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_VERIFY_FAIL, msg);
+    system_->SetGError(error, CHROMEOS_LOGIN_ERROR_VERIFY_FAIL, msg);
     return FALSE;
   }
   store_->Unwhitelist(email_address);
   io_thread_.message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &SessionManagerService::PersistWhitelist));
   return TRUE;
 }
 
 gboolean SessionManagerService::CheckWhitelist(gchar* email_address,
                                                GArray** OUT_signature,
                                                GError** error) {
   std::string encoded;
   if (!store_->GetFromWhitelist(email_address, &encoded)) {
     const char msg[] = "The user is not whitelisted.";
     LOG(INFO) << msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_ILLEGAL_USER, msg);
+    system_->SetGError(error, CHROMEOS_LOGIN_ERROR_ILLEGAL_USER, msg);
     return FALSE;
   }
   std::string decoded;
   if (!base::Base64Decode(encoded, &decoded)) {
     const char msg[] = "Signature could not be decoded in CheckWhitelist.";
     LOG(ERROR) << msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_DECODE_FAIL, msg);
+    system_->SetGError(error, CHROMEOS_LOGIN_ERROR_DECODE_FAIL, msg);
     return FALSE;
   }
 
   *OUT_signature = g_array_sized_new(FALSE, FALSE, 1, decoded.length());
   g_array_append_vals(*OUT_signature, decoded.c_str(), decoded.length());
   return TRUE;
 }
 
 gboolean SessionManagerService::EnumerateWhitelisted(gchar*** OUT_whitelist,
                                                      GError** error) {
@@ skipping 12 matching lines @@
 
 gboolean SessionManagerService::Whitelist(gchar* email_address,
                                           GArray* signature,
                                           GError** error) {
   LOG(INFO) << "Whitelisting " << email_address;
   SessionManagerService::SigReturnCode verify_result =
       VerifyHelperArray(email_address, signature);
   if (verify_result == NO_KEY) {
     const char msg[] = "Attempt to whitelist before owner's key is set.";
     LOG(ERROR) << msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_NO_OWNER_KEY, msg);
+    system_->SetGError(error, CHROMEOS_LOGIN_ERROR_NO_OWNER_KEY, msg);
     return FALSE;
   } else if (verify_result == SIGNATURE_FAIL) {
     const char msg[] = "Signature could not be verified in Whitelist.";
     LOG(ERROR) << msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_VERIFY_FAIL, msg);
+    system_->SetGError(error, CHROMEOS_LOGIN_ERROR_VERIFY_FAIL, msg);
     return FALSE;
   }
   std::string data(signature->data, signature->len);
   return WhitelistHelper(email_address, data, error);
 }
 
 gboolean SessionManagerService::StoreProperty(gchar* name,
                                               gchar* value,
                                               GArray* signature,
                                               GError** error) {
   LOG(INFO) << "Setting pref " << name << "=" << value;
   SessionManagerService::SigReturnCode verify_result =
       VerifyHelperArray(base::StringPrintf("%s=%s", name, value), signature);
   if (verify_result == NO_KEY) {
     const char msg[] = "Attempt to store property before owner's key is set.";
     LOG(ERROR) << msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_NO_OWNER_KEY, msg);
+    system_->SetGError(error, CHROMEOS_LOGIN_ERROR_NO_OWNER_KEY, msg);
     return FALSE;
   } else if (verify_result == SIGNATURE_FAIL) {
     const char msg[] = "Signature could not be verified in StoreProperty.";
     LOG(ERROR) << msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_VERIFY_FAIL, msg);
+    system_->SetGError(error, CHROMEOS_LOGIN_ERROR_VERIFY_FAIL, msg);
     return FALSE;
   }
   std::string data(signature->data, signature->len);
   return SetPropertyHelper(name, value, data, error);
 }
 
 gboolean SessionManagerService::RetrieveProperty(gchar* name,
                                                  gchar** OUT_value,
                                                  GArray** OUT_signature,
                                                  GError** error) {
@@ skipping 10 matching lines @@
 
 void SessionManagerService::SendBooleanReply(DBusGMethodInvocation* context,
                                              bool succeeded) {
   if (context)
     dbus_g_method_return(context, succeeded);
 }
 
 gboolean SessionManagerService::StorePolicy(GArray* policy_blob,
                                             DBusGMethodInvocation* context) {
   std::string policy_str(policy_blob->data, policy_blob->len);
-  enterprise_management::PolicyFetchResponse policy;
+  em::PolicyFetchResponse policy;
   if (!policy.ParseFromString(policy_str) ||
       !policy.has_policy_data() ||
       !policy.has_policy_data_signature()) {
     const char msg[] = "Unable to parse policy protobuf.";
     LOG(ERROR) << msg;
-    SetAndSendGError(CHROMEOS_LOGIN_ERROR_DECODE_FAIL, context, msg);
+    system_->SetAndSendGError(CHROMEOS_LOGIN_ERROR_DECODE_FAIL, context, msg);
     return FALSE;
   }
 
   // Determine if the policy has pushed a new owner key and, if so, set it and
   // schedule a task to persist it to disk.
   if (policy.has_new_public_key() && !key_->Equals(policy.new_public_key())) {
     // The policy contains a new key, and it is different from |key_|.
     std::vector<uint8> der;
     nss_->BlobFromBuffer(policy.new_public_key(), &der);
 
     if (session_started_) {
       bool rotated = false;
       if (policy.has_new_public_key_signature()) {
         // Graceful key rotation.
         std::vector<uint8> sig;
         nss_->BlobFromBuffer(policy.new_public_key_signature(), &sig);
         rotated = key_->Rotate(der, sig);
       }
       if (!rotated) {
         const char msg[] = "Failed attempted key rotation!";
         LOG(ERROR) << msg;
-        SetAndSendGError(CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY, context, msg);
+        system_->SetAndSendGError(CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY,
+                                 context,
+                                 msg);
         return FALSE;
       }
     } else {
       // Force a new key, regardless of whether we have one or not.
       if (key_->IsPopulated()) {
         key_->ClobberCompromisedKey(der);
         LOG(INFO) << "Clobbered existing key outside of session";
       } else {
         CHECK(key_->PopulateFromBuffer(der));  // Should be unable to fail.
         LOG(INFO) << "Setting key outside of session";
       }
     }
     // If here, need to persit new key to disk.  Already loaded key into memory.
     io_thread_.message_loop()->PostTask(
         FROM_HERE, NewRunnableMethod(this, &SessionManagerService::PersistKey));
   }
 
   // Validate signature on policy and persist to disk
   const std::string& sig = policy.policy_data_signature();
   SessionManagerService::SigReturnCode verify_result =
       VerifyHelper(policy.policy_data(), sig.c_str(), sig.length());
   if (verify_result == NO_KEY) {
     NOTREACHED() << "Should have set the key earlier in this function!";
     return FALSE;
   } else if (verify_result == SIGNATURE_FAIL) {
     const char msg[] = "Signature could not be verified in StorePolicy.";
     LOG(ERROR) << msg;
-    SetAndSendGError(CHROMEOS_LOGIN_ERROR_VERIFY_FAIL, context, msg);
+    system_->SetAndSendGError(CHROMEOS_LOGIN_ERROR_VERIFY_FAIL, context, msg);
     return FALSE;
   }
   policy_->Set(policy);
   io_thread_.message_loop()->PostTask(
       FROM_HERE, NewRunnableMethod(this, &SessionManagerService::PersistPolicy,
                                    context));
   return TRUE;
 }
 
 gboolean SessionManagerService::RetrievePolicy(GArray** OUT_policy_blob,
                                                GError** error) {
   std::string polstr;
-  if (!policy_->Get(&polstr)) {
+  if (!policy_->SerializeToString(&polstr)) {
     const char msg[] = "Unable to serialize policy protobuf.";
     LOG(ERROR) << msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_ENCODE_FAIL, msg);
+    system_->SetGError(error, CHROMEOS_LOGIN_ERROR_ENCODE_FAIL, msg);
     return FALSE;
   }
   *OUT_policy_blob = g_array_sized_new(FALSE, FALSE, 1, polstr.length());
   if (!*OUT_policy_blob) {
     const char msg[] = "Unable to allocate memory for response.";
     LOG(ERROR) << msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_DECODE_FAIL, msg);
+    system_->SetGError(error, CHROMEOS_LOGIN_ERROR_DECODE_FAIL, msg);
     return FALSE;
   }
   g_array_append_vals(*OUT_policy_blob, polstr.c_str(), polstr.length());
   return TRUE;
 }
 
 gboolean SessionManagerService::LockScreen(GError** error) {
   screen_locked_ = TRUE;
   system_->SendSignalToChromium(chromium::kLockScreenSignal, NULL);
   LOG(INFO) << "LockScreen";
@@ skipping 15 matching lines @@
   std::vector<int>::iterator child_pid_it =
       std::find(child_pids_.begin(), child_pids_.end(), child_pid);
   size_t child_index = child_pid_it - child_pids_.begin();
 
   if (child_pid_it == child_pids_.end() ||
       child_jobs_[child_index]->GetName() != "chrome") {
     // If we didn't find the pid, or we don't think that job was chrome...
     *OUT_done = FALSE;
     const char msg[] = "Provided pid is unknown.";
     LOG(ERROR) << msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_UNKNOWN_PID, msg);
+    system_->SetGError(error, CHROMEOS_LOGIN_ERROR_UNKNOWN_PID, msg);
     return FALSE;
   }
 
   // Waiting for Chrome to shutdown takes too much time.
   // We're killing it immediately hoping that data Chrome uses before
   // logging in is not corrupted.
   // TODO(avayvod): Remove RestartJob when crosbug.com/6924 is fixed.
   KillChild(child_jobs_[child_index], child_pid);
 
   char arguments_buffer[kMaxArgumentsSize + 1];
@@ skipping 145 matching lines @@
 
 void SessionManagerService::PersistWhitelist() {
   LOG(INFO) << "Persisting Whitelist to disk.";
   bool what_happened = store_->Persist();
   message_loop_->PostTask(
       FROM_HERE, NewRunnableMethod(this, &SessionManagerService::SendSignal,
                                    chromium::kWhitelistChangeCompleteSignal,
                                    what_happened));
 }
 
-// static
-void SessionManagerService::SetGError(GError** error,
-                                      ChromeOSLoginError code,
-                                      const char* message) {
-  g_set_error(error, CHROMEOS_LOGIN_ERROR, code, "Login error: %s", message);
-}
-
-// static
-void SessionManagerService::SetAndSendGError(ChromeOSLoginError code,
-                                             DBusGMethodInvocation* context,
-                                             const char* msg) {
-  GError* error = NULL;
-  SetGError(&error, code, msg);
-  dbus_g_method_return_error(context, error);
-  g_error_free(error);
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // Utility Methods
 
 // This can probably be more efficient, if it needs to be.
 // static
 bool SessionManagerService::ValidateEmail(const string& email_address) {
   if (email_address.find_first_not_of(kLegalCharacters) != string::npos)
     return false;
 
   size_t at = email_address.find(kEmailSeparator);
@@ skipping 73 matching lines @@
   // Also handle SIGINT - when the user terminates the browser via Ctrl+C.
   // If the browser process is being debugged, GDB will catch the SIGINT first.
   action.sa_handler = SIGINTHandler;
   CHECK(sigaction(SIGINT, &action, NULL) == 0);
   // And SIGHUP, for when the terminal disappears. On shutdown, many Linux
   // distros send SIGHUP, SIGTERM, and then SIGKILL.
   action.sa_handler = SIGHUPHandler;
   CHECK(sigaction(SIGHUP, &action, NULL) == 0);
 }
 
-gboolean SessionManagerService::CurrentUserIsOwner(GError** error) {
+gboolean SessionManagerService::CurrentUserIsOwner() {
   std::string value;
   std::string decoded;
-  if (!GetPropertyHelper(kDeviceOwnerPref, &value, &decoded, error))
+  if (!GetPropertyHelper(kDeviceOwnerPref, &value, &decoded, NULL))
     return FALSE;
   std::string was_signed = base::StringPrintf("%s=%s",
                                               kDeviceOwnerPref,
                                               value.c_str());
   if (VerifyHelper(was_signed, decoded.c_str(), decoded.length()) != SUCCESS) {
-    const char msg[] = "Owner pref signature could not be verified.";
-    LOG(ERROR) << msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_VERIFY_FAIL, msg);
+    LOG(ERROR) << "Owner pref signature could not be verified.";
     return FALSE;
   }
   return value == current_user_;
 }
 
 gboolean SessionManagerService::CurrentUserHasOwnerKey(
     const std::vector<uint8>& pub_key,
     GError** error) {
   if (!nss_->OpenUserDB()) {
     const char msg[] = "Could not open the current user's NSS database.";
     LOG(ERROR) << msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_NO_USER_NSSDB, msg);
+    system_->SetGError(error, CHROMEOS_LOGIN_ERROR_NO_USER_NSSDB, msg);
     return FALSE;
   }
   if (!nss_->GetPrivateKey(pub_key)) {
     const char msg[] = "Could not verify that public key belongs to the owner.";
     LOG(WARNING) << msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY, msg);
+    system_->SetGError(error, CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY, msg);
     return FALSE;
   }
   return TRUE;
 }
 
 gboolean SessionManagerService::ValidateAndCacheUserEmail(
     const gchar* email_address,
     GError** error) {
   // basic validity checking; avoid buffer overflows here, and
   // canonicalize the email address a little.
   char email[kMaxEmailSize + 1];
   snprintf(email, sizeof(email), "%s", email_address);
   email[kMaxEmailSize] = '\0';  // Just to be sure.
   string email_string(email);
   if (email_string != kIncognitoUser && !ValidateEmail(email_string)) {
     const char msg[] = "Provided email address is not valid.  ASCII only.";
     LOG(ERROR) << msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_INVALID_EMAIL, msg);
+    system_->SetGError(error, CHROMEOS_LOGIN_ERROR_INVALID_EMAIL, msg);
     return FALSE;
   }
   current_user_ = StringToLowerASCII(email_string);
   return TRUE;
 }
 
 int SessionManagerService::FindChildByPid(int pid) {
   for (int i = 0; i < child_pids_.size(); ++i) {
     if (child_pids_[i] == pid)
       return i;
@@ skipping 32 matching lines @@
                             current_user_,
                             "Could not sign owner property.",
                             error)) {
     return FALSE;
   }
   return SignAndWhitelist(current_user_, "Could not whitelist owner.", error);
 }
 
 gboolean SessionManagerService::SignAndStoreProperty(const std::string& name,
                                                      const std::string& value,
-                                                     const std::string& err_msg,
+                                                     const std::string& msg,
                                                      GError** error) {
   std::vector<uint8> signature;
   std::string to_sign = base::StringPrintf("%s=%s",
                                            kDeviceOwnerPref,
                                            current_user_.c_str());
   const uint8* data = reinterpret_cast<const uint8*>(to_sign.c_str());
   if (!key_->Sign(data, to_sign.length(), &signature)) {
-    LOG_IF(ERROR, error) << err_msg;
-    LOG_IF(WARNING, !error) << err_msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY, err_msg.c_str());
+    LOG_IF(ERROR, error) << msg;
+    LOG_IF(WARNING, !error) << msg;
+    system_->SetGError(error, CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY, msg.c_str());
     return FALSE;
   }
   std::string signature_string(reinterpret_cast<const char*>(&signature[0]),
                                signature.size());
   return SetPropertyHelper(kDeviceOwnerPref,
                            current_user_,
                            signature_string,
                            error);
 }
 
 gboolean SessionManagerService::SignAndWhitelist(const std::string& email,
-                                                 const std::string& err_msg,
+                                                 const std::string& msg,
                                                  GError** error) {
   std::vector<uint8> signature;
   const uint8* data = reinterpret_cast<const uint8*>(current_user_.c_str());
   if (!key_->Sign(data, current_user_.length(), &signature)) {
-    LOG_IF(ERROR, error) << err_msg;
-    LOG_IF(WARNING, !error) << err_msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY, err_msg.c_str());
+    LOG_IF(ERROR, error) << msg;
+    LOG_IF(WARNING, !error) << msg;
+    system_->SetGError(error, CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY, msg.c_str());
     return FALSE;
   }
   std::string signature_string(reinterpret_cast<const char*>(&signature[0]),
                                signature.size());
   return WhitelistHelper(current_user_, signature_string, error);
 }
 
 gboolean SessionManagerService::SetPropertyHelper(const std::string& name,
                                                   const std::string& value,
                                                   const std::string& signature,
                                                   GError** error) {
   std::string encoded;
   if (!base::Base64Encode(signature, &encoded)) {
     const char msg[] = "Signature could not be encoded.";
     LOG(ERROR) << msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_ENCODE_FAIL, msg);
+    system_->SetGError(error, CHROMEOS_LOGIN_ERROR_ENCODE_FAIL, msg);
     return FALSE;
   }
   store_->Set(name, value, encoded);
   io_thread_.message_loop()->PostTask(
       FROM_HERE, NewRunnableMethod(this, &SessionManagerService::PersistStore));
   return TRUE;
 }
 
 SessionManagerService::SigReturnCode
 SessionManagerService::VerifyHelperArray(const std::string& data, GArray* sig) {
@@ skipping 15 matching lines @@
   return SUCCESS;
 }
 
 gboolean SessionManagerService::WhitelistHelper(const std::string& email,
                                                 const std::string& signature,
                                                 GError** error) {
   std::string encoded;
   if (!base::Base64Encode(signature, &encoded)) {
     const char msg[] = "Signature could not be encoded.";
     LOG(ERROR) << msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_ENCODE_FAIL, msg);
+    system_->SetGError(error, CHROMEOS_LOGIN_ERROR_ENCODE_FAIL, msg);
     return FALSE;
   }
   store_->Whitelist(email, encoded);
   io_thread_.message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &SessionManagerService::PersistWhitelist));
   return TRUE;
 }
 
 gboolean SessionManagerService::GetPropertyHelper(const std::string& name,
                                                   std::string* OUT_value,
                                                   std::string* OUT_signature,
-                                                  GError** error) {
+                                                  GError** err) {
   std::string encoded;
   if (!store_->Get(name, OUT_value, &encoded)) {
-    std::string error_msg =
+    std::string msg =
         base::StringPrintf("The requested property %s is unknown.",
                            name.c_str());
-    LOG(WARNING) << error_msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_UNKNOWN_PROPERTY, error_msg.c_str());
+    LOG(WARNING) << msg;
+    system_->SetGError(err, CHROMEOS_LOGIN_ERROR_UNKNOWN_PROPERTY, msg.c_str());
     return FALSE;
   }
   if (!base::Base64Decode(encoded, OUT_signature)) {
     const char msg[] = "Signature could not be decoded.";
     LOG(ERROR) << msg;
-    SetGError(error, CHROMEOS_LOGIN_ERROR_DECODE_FAIL, msg);
+    system_->SetGError(err, CHROMEOS_LOGIN_ERROR_DECODE_FAIL, msg);
     return FALSE;
   }
   return TRUE;
 }
 
 void SessionManagerService::SendSignal(const char signal_name[],
                                        bool succeeded) {
   system_->SendSignalToChromium(signal_name, succeeded ? "success" : "failure");
 }
 
@@ skipping 12 matching lines @@
       arg_list.push_back(args[i_arg]);
     }
   }
   if (arg_list.size()) {
     arg_lists.push_back(arg_list);
   }
   return arg_lists;
 }
 
 }  // namespace login_manager