Refactoring : Move AuthAttempt and Authenticators to chromeos/login

chromeos/login/auth/extended_authenticator.cc

 // Copyright 2014 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 "chrome/browser/chromeos/login/auth/extended_authenticator.h"
+#include "chromeos/login/auth/extended_authenticator.h"
 
 #include "base/bind.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
-#include "chrome/browser/chromeos/boot_times_loader.h"
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/cryptohome/cryptohome_parameters.h"
 #include "chromeos/cryptohome/homedir_methods.h"
 #include "chromeos/cryptohome/system_salt_getter.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/login/auth/auth_status_consumer.h"
 #include "chromeos/login/auth/key.h"
 #include "chromeos/login/auth/user_context.h"
+#include "chromeos/login_event_recorder.h"
 #include "content/public/browser/browser_thread.h"

[stevenjb, 2014/07/22 16:38:43]

Layering violation.

[Denis Kuznetsov (DE-MUC), 2014/07/23 17:34:11]

Done.

 #include "crypto/sha2.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using content::BrowserThread;
 
 namespace chromeos {
 
 namespace {
 
 void RecordStartMarker(const std::string& marker) {
   std::string full_marker = "Cryptohome-";
   full_marker.append(marker);
   full_marker.append("-Start");
-  chromeos::BootTimesLoader::Get()->AddLoginTimeMarker(full_marker, false);
+  chromeos::LoginEventRecorder::Get()->AddLoginTimeMarker(full_marker, false);
 }
 
 void RecordEndMarker(const std::string& marker) {
   std::string full_marker = "Cryptohome-";
   full_marker.append(marker);
   full_marker.append("-End");
-  chromeos::BootTimesLoader::Get()->AddLoginTimeMarker(full_marker, false);
+  chromeos::LoginEventRecorder::Get()->AddLoginTimeMarker(full_marker, false);
 }
 
 }  // namespace
 
 ExtendedAuthenticator::ExtendedAuthenticator(NewAuthStatusConsumer* consumer)
     : salt_obtained_(false), consumer_(consumer), old_consumer_(NULL) {
   SystemSaltGetter::Get()->GetSystemSalt(
       base::Bind(&ExtendedAuthenticator::OnSaltObtained, this));
 }
 
@@ skipping 98 matching lines @@
 
 void ExtendedAuthenticator::TransformKeyIfNeeded(
     const UserContext& user_context,
     const ContextCallback& callback) {
   if (user_context.GetKey()->GetKeyType() != Key::KEY_TYPE_PASSWORD_PLAIN) {
     callback.Run(user_context);
     return;
   }
 
   if (!salt_obtained_) {
-    system_salt_callbacks_.push_back(base::Bind(
-        &ExtendedAuthenticator::TransformKeyIfNeeded,
-        this,
-        user_context,
-        callback));
+    system_salt_callbacks_.push_back(
+        base::Bind(&ExtendedAuthenticator::TransformKeyIfNeeded,
+                   this,
+                   user_context,
+                   callback));
     return;
   }
 
   UserContext transformed_context = user_context;
   transformed_context.GetKey()->Transform(Key::KEY_TYPE_SALTED_SHA256_TOP_HALF,
                                           system_salt_);
   callback.Run(transformed_context);
 }
 
 ExtendedAuthenticator::~ExtendedAuthenticator() {
 }
 
 void ExtendedAuthenticator::OnSaltObtained(const std::string& system_salt) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   salt_obtained_ = true;
   system_salt_ = system_salt;
   for (std::vector<base::Closure>::const_iterator it =
            system_salt_callbacks_.begin();
-       it != system_salt_callbacks_.end(); ++it) {
+       it != system_salt_callbacks_.end();
+       ++it) {
     it->Run();
   }
   system_salt_callbacks_.clear();
 }
 
 void ExtendedAuthenticator::DoAuthenticateToMount(
     const ResultCallback& success_callback,
     const UserContext& user_context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 178 matching lines @@
   if (consumer_)
     consumer_->OnAuthenticationFailure(state);
 
   if (old_consumer_) {
     AuthFailure failure(AuthFailure::UNLOCK_FAILED);
     old_consumer_->OnAuthFailure(failure);
   }
 }
 
 }  // namespace chromeos