Don't register gmail users at the device management server

chrome/browser/policy/device_token_fetcher.h

 // Copyright (c) 2010 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.
 
 #ifndef CHROME_BROWSER_POLICY_DEVICE_TOKEN_FETCHER_H_
 #define CHROME_BROWSER_POLICY_DEVICE_TOKEN_FETCHER_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/observer_list.h"
 #include "base/ref_counted.h"
 #include "base/waitable_event.h"
 #include "chrome/browser/policy/device_management_backend.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_registrar.h"
 
-class TokenService;
+class Profile;
 
 namespace policy {
 
 namespace em = enterprise_management;
 
 // Fetches the device token that can be used for policy requests with the device
 // management server, either from disk if it already has been successfully
 // requested, otherwise from the device management server. An instance of the
 // fetcher is shared as a singleton by all users of the device management token
 // to ensure they all get the same token.
@@ skipping 31 matching lines @@
     }
    private:
     DeviceTokenFetcher* token_fetcher_;
     std::vector<DeviceTokenFetcher::Observer*> observers_;
   };
 
   // Requests to the device management server are sent through |backend|. It
   // obtains the authentication token from |token_service|. The fetcher stores
   // the device token to |token_path| once it's retrieved from the server.
   DeviceTokenFetcher(DeviceManagementBackend* backend,
-                     TokenService* token_service,
+                     Profile* profile,
                      const FilePath& token_path);
   virtual ~DeviceTokenFetcher() {}
 
   // NotificationObserver method overrides:
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   // DeviceManagementBackend::DeviceRegisterResponseDelegate method overrides:
   virtual void HandleRegisterResponse(
@@ skipping 23 matching lines @@
   // Returns the device ID for this device. If no such ID has been set yet, a
   // new ID is generated and returned.
   std::string GetDeviceID();
 
   // True if the fetcher has a valid AuthToken for the device management server.
   bool HasAuthToken() const { return !auth_token_.empty(); }
 
   // True if the device token has been fetched and is valid.
   bool IsTokenValid() const;
 
+ protected:
+  // Returns the email address of the currently logged-in user.
+  virtual std::string GetCurrentUser();
+
+  // Used to identify GOOGLE_SIGNIN_SUCCESSFUL notifications from the owning
+  // profile, and to query for the current username.
+  Profile* profile_; // weak
+
  private:
   friend class DeviceTokenFetcherTest;
 
   // The different states that the fetcher can be in during the process of
   // getting the device token.
   enum FetcherState {
     kStateNotStarted,
     kStateLoadDeviceTokenFromDisk,
     kStateReadyToRequestDeviceTokenFromServer,
     kStateRequestingDeviceTokenFromServer,
@@ skipping 52 matching lines @@
                                      const std::string& token,
                                      const std::string& device_id);
 
   // Generates a new device ID used to register the device with the device
   // management server and generate the device token.
   static std::string GenerateNewDeviceID();
 
   ObserverList<Observer, true> observer_list_;
   FilePath token_path_;
   DeviceManagementBackend* backend_;  // weak
-  TokenService* token_service_;
   FetcherState state_;
   std::string device_token_;
   std::string device_id_;
 
   // Contains the AuthToken for the device management server. Empty if the
   // AuthToken hasn't been issued yet or that was an error getting the
   // AuthToken.
   std::string auth_token_;
 
   // An event that is signaled only once the device token has been fetched
   // or it has been determined that there was an error during fetching.
   base::WaitableEvent device_token_load_complete_event_;
 
   // Registers the fetcher for notification of successful Gaia logins.
   NotificationRegistrar registrar_;
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_POLICY_DEVICE_TOKEN_FETCHER_H_