1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CHROME_BROWSER_CHROMEOS_POLICY_CLOUD_EXTERNAL_DATA_POLICY_OBSERVER_H_ 6 #define CHROME_BROWSER_CHROMEOS_POLICY_CLOUD_EXTERNAL_DATA_POLICY_OBSERVER_H_ 7 8 #include <map> 9 #include <string> 10 11 #include "base/basictypes.h" 12 #include "base/compiler_specific.h" 13 #include "base/memory/linked_ptr.h" 14 #include "base/memory/scoped_ptr.h" 15 #include "base/memory/weak_ptr.h" 16 #include "chrome/browser/chromeos/policy/device_local_account_policy_service.h" 17 #include "chrome/browser/chromeos/settings/cros_settings.h" 18 #include "components/policy/core/common/policy_map.h" 19 #include "content/public/browser/notification_observer.h" 20 #include "content/public/browser/notification_registrar.h" 21 22 namespace chromeos { 23 class UserManager; 24 } 25 26 namespace policy { 27 28 // Helper for implementing policies referencing external data: This class 29 // observes a given |policy_| and fetches the external data that it references 30 // for all users on the device. Notifications are emitted when an external data 31 // reference is set, cleared or an external data fetch completes successfully. 32 // 33 // State is kept at runtime only: External data references that already exist 34 // when the class is instantiated are considered new, causing a notification to 35 // be emitted that an external data reference has been set and the referenced 36 // external data to be fetched. 37 class CloudExternalDataPolicyObserver 38 : public content::NotificationObserver, 39 public DeviceLocalAccountPolicyService::Observer { 40 public: 41 class Delegate { 42 public: 43 // Invoked when an external data reference is set for |user_id|. 44 virtual void OnExternalDataSet(const std::string& policy, 45 const std::string& user_id); 46 47 // Invoked when the external data reference is cleared for |user_id|. 48 virtual void OnExternalDataCleared(const std::string& policy, 49 const std::string& user_id); 50 51 // Invoked when the external data referenced for |user_id| has been fetched. 52 // Failed fetches are retried and the method is called only when a fetch 53 // eventually succeeds. If a fetch fails permanently (e.g. because the 54 // external data reference specifies an invalid URL), the method is not 55 // called at all. 56 virtual void OnExternalDataFetched(const std::string& policy, 57 const std::string& user_id, 58 scoped_ptr<std::string> data); 59 60 protected: 61 virtual ~Delegate(); 62 }; 63 64 CloudExternalDataPolicyObserver( 65 chromeos::CrosSettings* cros_settings, 66 chromeos::UserManager* user_manager, 67 DeviceLocalAccountPolicyService* device_local_account_policy_service, 68 const std::string& policy, 69 Delegate* delegate); 70 virtual ~CloudExternalDataPolicyObserver(); 71 72 void Init(); 73 74 // content::NotificationObserver: 75 virtual void Observe(int type, 76 const content::NotificationSource& source, 77 const content::NotificationDetails& details) OVERRIDE; 78 79 // DeviceLocalAccountPolicyService::Observer: 80 virtual void OnPolicyUpdated(const std::string& user_id) OVERRIDE; 81 virtual void OnDeviceLocalAccountsChanged() OVERRIDE; 82 83 private: 84 // Helper class that observes |policy_| for a logged-in user. 85 class PolicyServiceObserver; 86 87 void RetrieveDeviceLocalAccounts(); 88 89 // Handles the new policy map |entry| for |user_id| by canceling any external 90 // data fetch currently in progress, emitting a notification that an external 91 // data reference has been cleared (if |entry| is NULL) or set (otherwise), 92 // starting a new external data fetch in the latter case. 93 void HandleExternalDataPolicyUpdate(const std::string& user_id, 94 const PolicyMap::Entry* entry); 95 96 void OnExternalDataFetched(const std::string& user_id, 97 scoped_ptr<std::string> data); 98 99 // A map from each device-local account user ID to its current policy map 100 // entry for |policy_|. 101 typedef std::map<std::string, PolicyMap::Entry> DeviceLocalAccountEntryMap; 102 DeviceLocalAccountEntryMap device_local_account_entries_; 103 104 // A map from each logged-in user to the helper that observes |policy_| in the 105 // user's PolicyService. 106 typedef std::map<std::string, linked_ptr<PolicyServiceObserver> > 107 LoggedInUserObserverMap; 108 LoggedInUserObserverMap logged_in_user_observers_; 109 110 chromeos::CrosSettings* cros_settings_; 111 chromeos::UserManager* user_manager_; 112 DeviceLocalAccountPolicyService* device_local_account_policy_service_; 113 114 // The policy that |this| observes. 115 std::string policy_; 116 117 Delegate* delegate_; 118 119 content::NotificationRegistrar notification_registrar_; 120 scoped_ptr<chromeos::CrosSettings::ObserverSubscription> 121 device_local_accounts_subscription_; 122 123 // A map from user ID to a base::WeakPtr for each external data fetch 124 // currently in progress. This allows fetches to be effectively be canceled by 125 // invalidating the pointers. 126 typedef base::WeakPtrFactory<CloudExternalDataPolicyObserver> 127 WeakPtrFactory; 128 typedef std::map<std::string, linked_ptr<WeakPtrFactory> > FetchWeakPtrMap; 129 FetchWeakPtrMap fetch_weak_ptrs_; 130 131 base::WeakPtrFactory<CloudExternalDataPolicyObserver> weak_factory_; 132 133 DISALLOW_COPY_AND_ASSIGN(CloudExternalDataPolicyObserver); 134 }; 135 136 } // namespace policy 137 138 #endif // CHROME_BROWSER_CHROMEOS_POLICY_CLOUD_EXTERNAL_DATA_POLICY_OBSERVER_H_ 139