[Cleanup] Move the Easy Unlock metrics files out of the chromeos directory.

chrome/browser/signin/easy_unlock_service_signin_chromeos.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/signin/easy_unlock_service_signin_chromeos.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/sys_info.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_key_manager.h"
-#include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_metrics.h"
 #include "chrome/browser/chromeos/login/session/user_session_manager.h"
+#include "chrome/browser/signin/easy_unlock_metrics.h"
 #include "chromeos/login/auth/user_context.h"
 #include "chromeos/tpm/tpm_token_loader.h"
 
 namespace {
 
 // The maximum allowed backoff interval when waiting for cryptohome to start.
 uint32 kMaxCryptohomeBackoffIntervalMs = 10000u;
 
 // If the data load fails, the initial interval after which the load will be
 // retried. Further intervals will exponentially increas by factor 2.
@@ skipping 139 matching lines @@
   if (!data || data->devices.size() <= device_index)
     return std::string();
   return data->devices[device_index].wrapped_secret;
 }
 
 void EasyUnlockServiceSignin::RecordEasySignInOutcome(
     const std::string& user_id,
     bool success) const {
   DCHECK_EQ(GetUserEmail(), user_id);
 
-  chromeos::RecordEasyUnlockLoginEvent(success
-                                           ? chromeos::EASY_SIGN_IN_SUCCESS
-                                           : chromeos::EASY_SIGN_IN_FAILURE);
+  RecordEasyUnlockLoginEvent(
+      success ? EASY_SIGN_IN_SUCCESS : EASY_SIGN_IN_FAILURE);
   DVLOG(1) << "Easy sign-in " << (success ? "success" : "failure");
 }
 
 void EasyUnlockServiceSignin::RecordPasswordLoginEvent(
     const std::string& user_id) const {
   // This happens during tests where user could login without pod focusing.
   if (GetUserEmail() != user_id)
     return;
 
-  chromeos::EasyUnlockLoginEvent event =
-      chromeos::EASY_SIGN_IN_LOGIN_EVENT_COUNT;
+  EasyUnlockLoginEvent event = EASY_SIGN_IN_LOGIN_EVENT_COUNT;
   if (!GetRemoteDevices() ||
       GetHardlockState() == EasyUnlockScreenlockStateHandler::NO_PAIRING) {
-    event = chromeos::PASSWORD_SIGN_IN_NO_PAIRING;
+    event = PASSWORD_SIGN_IN_NO_PAIRING;
   } else if (GetHardlockState() !=
              EasyUnlockScreenlockStateHandler::NO_HARDLOCK) {
     switch (GetHardlockState()) {
       case EasyUnlockScreenlockStateHandler::NO_HARDLOCK:
       case EasyUnlockScreenlockStateHandler::NO_PAIRING:
         NOTREACHED();
         break;
       case EasyUnlockScreenlockStateHandler::USER_HARDLOCK:
-        event = chromeos::PASSWORD_SIGN_IN_USER_HARDLOCK;
+        event = PASSWORD_SIGN_IN_USER_HARDLOCK;
         break;
       case EasyUnlockScreenlockStateHandler::PAIRING_CHANGED:
-        event = chromeos::PASSWORD_SIGN_IN_PAIRING_CHANGED;
+        event = PASSWORD_SIGN_IN_PAIRING_CHANGED;
         break;
       case EasyUnlockScreenlockStateHandler::LOGIN_FAILED:
-        event = chromeos::PASSWORD_SIGN_IN_LOGIN_FAILED;
+        event = PASSWORD_SIGN_IN_LOGIN_FAILED;
         break;
       case EasyUnlockScreenlockStateHandler::PAIRING_ADDED:
-        event = chromeos::PASSWORD_SIGN_IN_PAIRING_ADDED;
+        event = PASSWORD_SIGN_IN_PAIRING_ADDED;
         break;
     }
   } else if (!screenlock_state_handler()) {
-    event = chromeos::PASSWORD_SIGN_IN_NO_SCREENLOCK_STATE_HANDLER;
+    event = PASSWORD_SIGN_IN_NO_SCREENLOCK_STATE_HANDLER;
   } else {
     switch (screenlock_state_handler()->state()) {
       case EasyUnlockScreenlockStateHandler::STATE_INACTIVE:
-        event = chromeos::PASSWORD_SIGN_IN_SERVICE_NOT_ACTIVE;
+        event = PASSWORD_SIGN_IN_SERVICE_NOT_ACTIVE;
         break;
       case EasyUnlockScreenlockStateHandler::STATE_NO_BLUETOOTH:
-        event = chromeos::PASSWORD_SIGN_IN_NO_BLUETOOTH;
+        event = PASSWORD_SIGN_IN_NO_BLUETOOTH;
         break;
       case EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING:
-        event = chromeos::PASSWORD_SIGN_IN_BLUETOOTH_CONNECTING;
+        event = PASSWORD_SIGN_IN_BLUETOOTH_CONNECTING;
         break;
       case EasyUnlockScreenlockStateHandler::STATE_NO_PHONE:
-        event = chromeos::PASSWORD_SIGN_IN_NO_PHONE;
+        event = PASSWORD_SIGN_IN_NO_PHONE;
         break;
       case EasyUnlockScreenlockStateHandler::STATE_PHONE_NOT_AUTHENTICATED:
-        event = chromeos::PASSWORD_SIGN_IN_PHONE_NOT_AUTHENTICATED;
+        event = PASSWORD_SIGN_IN_PHONE_NOT_AUTHENTICATED;
         break;
       case EasyUnlockScreenlockStateHandler::STATE_PHONE_LOCKED:
-        event = chromeos::PASSWORD_SIGN_IN_PHONE_LOCKED;
+        event = PASSWORD_SIGN_IN_PHONE_LOCKED;
         break;
       case EasyUnlockScreenlockStateHandler::STATE_PHONE_UNLOCKABLE:
-        event = chromeos::PASSWORD_SIGN_IN_PHONE_NOT_LOCKABLE;
+        event = PASSWORD_SIGN_IN_PHONE_NOT_LOCKABLE;
         break;
       case EasyUnlockScreenlockStateHandler::STATE_PHONE_UNSUPPORTED:
-        event = chromeos::PASSWORD_SIGN_IN_PHONE_UNSUPPORTED;
+        event = PASSWORD_SIGN_IN_PHONE_UNSUPPORTED;
         break;
       case EasyUnlockScreenlockStateHandler::STATE_RSSI_TOO_LOW:
-        event = chromeos::PASSWORD_SIGN_IN_RSSI_TOO_LOW;
+        event = PASSWORD_SIGN_IN_RSSI_TOO_LOW;
         break;
       case EasyUnlockScreenlockStateHandler::STATE_TX_POWER_TOO_HIGH:
-        event = chromeos::PASSWORD_SIGN_IN_TX_POWER_TOO_HIGH;
+        event = PASSWORD_SIGN_IN_TX_POWER_TOO_HIGH;
         break;
       case EasyUnlockScreenlockStateHandler::
                STATE_PHONE_LOCKED_AND_TX_POWER_TOO_HIGH:
-        event = chromeos::PASSWORD_SIGN_IN_PHONE_LOCKED_AND_TX_POWER_TOO_HIGH;
+        event = PASSWORD_SIGN_IN_PHONE_LOCKED_AND_TX_POWER_TOO_HIGH;
         break;
       case EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED:
-        event = chromeos::PASSWORD_SIGN_IN_WITH_AUTHENTICATED_PHONE;
+        event = PASSWORD_SIGN_IN_WITH_AUTHENTICATED_PHONE;
         break;
     }
   }
 
-  chromeos::RecordEasyUnlockLoginEvent(event);
+  RecordEasyUnlockLoginEvent(event);
   DVLOG(1) << "EasySignIn password login event, event=" << event;
 }
 
 void EasyUnlockServiceSignin::InitializeInternal() {
   if (chromeos::LoginState::Get()->IsUserLoggedIn())
     return;
 
   service_active_ = true;
 
   chromeos::LoginState::Get()->AddObserver(this);
@@ skipping 119 matching lines @@
     return NULL;
 
   std::map<std::string, UserData*>::const_iterator it =
       user_data_.find(user_id_);
   if (it == user_data_.end())
     return NULL;
   if (it->second->state != USER_DATA_STATE_LOADED)
     return NULL;
   return it->second;
 }