Add AffiliatedInvalidationServiceProvider

chrome/browser/chromeos/policy/affiliated_invalidation_service_provider.cc

Index: chrome/browser/chromeos/policy/affiliated_invalidation_service_provider.cc
diff --git a/chrome/browser/chromeos/policy/device_cloud_policy_invalidator.cc b/chrome/browser/chromeos/policy/affiliated_invalidation_service_provider.cc
similarity index 57%
copy from chrome/browser/chromeos/policy/device_cloud_policy_invalidator.cc
copy to chrome/browser/chromeos/policy/affiliated_invalidation_service_provider.cc
index 0f62250173b13889f551af53cc4c1fa1090c4cd6..8a82d94a29fc302e982f70fb0d30e0fe82880581 100644
--- a/chrome/browser/chromeos/policy/device_cloud_policy_invalidator.cc
+++ b/chrome/browser/chromeos/policy/affiliated_invalidation_service_provider.cc
@@ -2,26 +2,21 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/chromeos/policy/device_cloud_policy_invalidator.h"
+#include "chrome/browser/chromeos/policy/affiliated_invalidation_service_provider.h"
 
-#include <string>
 #include <vector>
 
 #include "base/logging.h"
-#include "base/message_loop/message_loop_proxy.h"
-#include "base/time/clock.h"
-#include "base/time/default_clock.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part_chromeos.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
-#include "chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos.h"
 #include "chrome/browser/chromeos/policy/ticl_device_settings_provider.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/device_identity_provider.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service_factory.h"
 #include "chrome/browser/invalidation/profile_invalidation_provider_factory.h"
-#include "chrome/browser/policy/cloud/cloud_policy_invalidator.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/chrome_content_client.h"
 #include "components/invalidation/invalidation_handler.h"
@@ -37,18 +32,17 @@
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "google_apis/gaia/identity_provider.h"
-#include "net/url_request/url_request_context_getter.h"
-#include "policy/proto/device_management_backend.pb.h"
-
-class Profile;
 
 namespace policy {
 
-class DeviceCloudPolicyInvalidator::InvalidationServiceObserver
+AffiliatedInvalidationServiceProvider::Consumer::~Consumer() {
+}
+
+class AffiliatedInvalidationServiceProvider::InvalidationServiceObserver
     : public syncer::InvalidationHandler {
  public:
   explicit InvalidationServiceObserver(
-      DeviceCloudPolicyInvalidator* parent,
+      AffiliatedInvalidationServiceProvider* parent,
       invalidation::InvalidationService* invalidation_service);
   virtual ~InvalidationServiceObserver();
 
@@ -63,16 +57,16 @@ class DeviceCloudPolicyInvalidator::InvalidationServiceObserver
   virtual std::string GetOwnerName() const override;
 
  private:
-  DeviceCloudPolicyInvalidator* parent_;
+  AffiliatedInvalidationServiceProvider* parent_;
   invalidation::InvalidationService* invalidation_service_;
   bool is_service_connected_;
 
   DISALLOW_COPY_AND_ASSIGN(InvalidationServiceObserver);
 };
 
-DeviceCloudPolicyInvalidator::InvalidationServiceObserver::
+AffiliatedInvalidationServiceProvider::InvalidationServiceObserver::
     InvalidationServiceObserver(
-        DeviceCloudPolicyInvalidator* parent,
+        AffiliatedInvalidationServiceProvider* parent,
         invalidation::InvalidationService* invalidation_service)
     : parent_(parent),
       invalidation_service_(invalidation_service),
@@ -81,23 +75,23 @@ DeviceCloudPolicyInvalidator::InvalidationServiceObserver::
   invalidation_service_->RegisterInvalidationHandler(this);
 }
 
-DeviceCloudPolicyInvalidator::InvalidationServiceObserver::
+AffiliatedInvalidationServiceProvider::InvalidationServiceObserver::
     ~InvalidationServiceObserver() {
   invalidation_service_->UnregisterInvalidationHandler(this);
 }
 
 invalidation::InvalidationService*
-DeviceCloudPolicyInvalidator::InvalidationServiceObserver::
+AffiliatedInvalidationServiceProvider::InvalidationServiceObserver::
     GetInvalidationService() {
   return invalidation_service_;
 }
 
-bool DeviceCloudPolicyInvalidator::InvalidationServiceObserver::
+bool AffiliatedInvalidationServiceProvider::InvalidationServiceObserver::
          IsServiceConnected() const {
   return is_service_connected_;
 }
 
-void DeviceCloudPolicyInvalidator::InvalidationServiceObserver::
+void AffiliatedInvalidationServiceProvider::InvalidationServiceObserver::
     OnInvalidatorStateChange(syncer::InvalidatorState state) {
   const bool is_service_connected = (state == syncer::INVALIDATIONS_ENABLED);
   if (is_service_connected == is_service_connected_)
@@ -110,20 +104,20 @@ void DeviceCloudPolicyInvalidator::InvalidationServiceObserver::
     parent_->OnInvalidationServiceDisconnected(invalidation_service_);
 }
 
-void DeviceCloudPolicyInvalidator::InvalidationServiceObserver::
+void AffiliatedInvalidationServiceProvider::InvalidationServiceObserver::
     OnIncomingInvalidation(
         const syncer::ObjectIdInvalidationMap& invalidation_map) {
 }
 
-std::string DeviceCloudPolicyInvalidator::InvalidationServiceObserver::
+std::string AffiliatedInvalidationServiceProvider::InvalidationServiceObserver::
     GetOwnerName() const {
-  return "DevicePolicy";
+  return "AffiliatedInvalidationService";
 }
 
-DeviceCloudPolicyInvalidator::DeviceCloudPolicyInvalidator()
-    : invalidation_service_(NULL),
-      highest_handled_invalidation_version_(0) {
-  // The DeviceCloudPolicyInvalidator should be created before any user
+AffiliatedInvalidationServiceProvider::AffiliatedInvalidationServiceProvider()
+    : invalidation_service_(nullptr),
+      consumer_count_(0) {
+  // The AffiliatedInvalidationServiceProvider should be created before any user
   // Profiles.
   DCHECK(g_browser_process->profile_manager()->GetLoadedProfiles().empty());
 
@@ -131,15 +125,13 @@ DeviceCloudPolicyInvalidator::DeviceCloudPolicyInvalidator()
   registrar_.Add(this,
                  chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
                  content::NotificationService::AllSources());
-
-  TryToCreateInvalidator();
 }
 
-DeviceCloudPolicyInvalidator::~DeviceCloudPolicyInvalidator() {
-  DestroyInvalidator();
+AffiliatedInvalidationServiceProvider::
+~AffiliatedInvalidationServiceProvider() {
 }
 
-void DeviceCloudPolicyInvalidator::Observe(
+void AffiliatedInvalidationServiceProvider::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
@@ -157,24 +149,87 @@ void DeviceCloudPolicyInvalidator::Observe(
   if (!user ||
       g_browser_process->platform_part()->browser_policy_connector_chromeos()->
           GetUserAffiliation(user->email()) != USER_AFFILIATION_MANAGED) {
-    // If the Profile belongs to a user who is not affiliated with the domain
-    // the device is enrolled into, ignore it.
+    // If the Profile belongs to a user who is not affiliated with the device's
+    // enrollment domain, ignore it.
     return;
   }
+
   // Create a state observer for the user's invalidation service.
+  invalidation::InvalidationService* invalidation_service =
+      invalidation_provider->GetInvalidationService();
   profile_invalidation_service_observers_.push_back(
-      new InvalidationServiceObserver(
-              this,
-              invalidation_provider->GetInvalidationService()));
+      new InvalidationServiceObserver(this, invalidation_service));
+
+  if (invalidation_service->GetInvalidatorState() ==
+          syncer::INVALIDATIONS_ENABLED) {

[Mattias Nissler (ping if slow), 2015/01/13 09:50:15]

nit: I guess a more consistent way of writing this would be

profile_invalidation_service_observers_.back().IsServiceConnected()

Or should this even be done by the InvalidationServiceObserver ctor?

[bartfab (slow), 2015/01/13 17:45:23]

Moved to the observer constructor.

+    // If the invalidation service is connected, check whether to switch to it.
+    OnInvalidationServiceConnected(invalidation_service);
+  }
+}
+
+void AffiliatedInvalidationServiceProvider::RegisterConsumer(
+    Consumer* consumer) {
+  if (consumers_.HasObserver(consumer))
+    return;
+
+  consumers_.AddObserver(consumer);
+  ++consumer_count_;
+
+  if (invalidation_service_)
+    consumer->OnInvalidationServiceSet(invalidation_service_);
+  else
+    FindConnectedInvalidationService();
+}
+
+void AffiliatedInvalidationServiceProvider::UnregisterConsumer(
+    Consumer* consumer) {
+  if (!consumers_.HasObserver(consumer))
+    return;
+
+  consumers_.RemoveObserver(consumer);
+  --consumer_count_;
+
+  if (invalidation_service_) {
+    consumer->OnInvalidationServiceReset();

[Mattias Nissler (ping if slow), 2015/01/13 09:50:15]

Uh, this is surprising to me - as a consumer I wouldn't expect any callbacks on
removing myself.

[bartfab (slow), 2015/01/13 17:45:23]

Removed.

+    if (consumer_count_ == 0) {
+      ResetInvalidationService();
+      DestroyDeviceInvalidationService();
+    }
+  }
+}
+
+invalidation::TiclInvalidationService*
+AffiliatedInvalidationServiceProvider::
+    GetDeviceInvalidationServiceForTest() const {
+  return device_invalidation_service_.get();
+}
 
-  TryToCreateInvalidator();
+bool
+AffiliatedInvalidationServiceProvider::
+    HasDeviceInvalidationServiceObserverForTest() const {
+  return device_invalidation_service_observer_;
 }
 
-void DeviceCloudPolicyInvalidator::OnInvalidationServiceConnected(
+int AffiliatedInvalidationServiceProvider::
+    GetProfileInvalidationServiceObserverCountForTest() const {
+  return profile_invalidation_service_observers_.size();
+}
+
+invalidation::InvalidationService*
+AffiliatedInvalidationServiceProvider::GetInvalidationServiceForTest() const {
+  return invalidation_service_;
+}
+
+void AffiliatedInvalidationServiceProvider::OnInvalidationServiceConnected(
     invalidation::InvalidationService* invalidation_service) {
+  if (consumer_count_ == 0) {
+    // If there are no consumers, no invalidation service is required.
+    return;
+  }
+
   if (!device_invalidation_service_) {
-    // The lack of a device-global invalidation service implies that a
-    // |CloudPolicyInvalidator| backed by another connected service exists
+    // The lack of a device-global invalidation service implies that another
+    // connected invalidation service is being made available to consumers
     // already. There is no need to switch from that to the service which just
     // connected.
     return;
@@ -182,37 +237,40 @@ void DeviceCloudPolicyInvalidator::OnInvalidationServiceConnected(
 
   if (invalidation_service != device_invalidation_service_.get()) {
     // If an invalidation service other than the device-global one connected,
-    // destroy the device-global service and the |CloudPolicyInvalidator| backed
-    // by it, if any.
-    DestroyInvalidator();
+    // destroy the device-global service.
+    ResetInvalidationService();
     DestroyDeviceInvalidationService();
   }
 
-  // Create a |CloudPolicyInvalidator| backed by the invalidation service which
-  // just connected.
-  CreateInvalidator(invalidation_service);
+  // Make the invalidation service that just connected available to consumers.
+  SetInvalidationService(invalidation_service);
 }
 
-void DeviceCloudPolicyInvalidator::OnInvalidationServiceDisconnected(
+void AffiliatedInvalidationServiceProvider::OnInvalidationServiceDisconnected(
     invalidation::InvalidationService* invalidation_service) {
   if (invalidation_service != invalidation_service_) {
-    // If the invalidation service which disconnected is not backing the current
-    // |CloudPolicyInvalidator|, return.
+    // If the invalidation service which disconnected was not being made
+    // available to consumers, return.
     return;
   }
 
-  // Destroy the |CloudPolicyInvalidator| backed by the invalidation service
-  // which just disconnected.
-  DestroyInvalidator();
+  // Notify consumers that the invalidation service they were using is no longer
+  // available.
+  ResetInvalidationService();
 
-  // Try to create a |CloudPolicyInvalidator| backed by another invalidation
-  // service.
-  TryToCreateInvalidator();
+  // Try to make another invalidation service available to consumers.
+  FindConnectedInvalidationService();
 }
 
-void DeviceCloudPolicyInvalidator::TryToCreateInvalidator() {
-  if (invalidator_) {
-    // If a |CloudPolicyInvalidator| exists already, return.
+void AffiliatedInvalidationServiceProvider::FindConnectedInvalidationService() {
+  if (consumer_count_ == 0) {
+    // If there are no consumers, no invalidation service is required.
+    return;
+  }
+
+  if (invalidation_service_) {
+    // If a connected invalidation service is being made available to consumers
+    // already, there is nothing to do.
     return;
   }
 
@@ -221,10 +279,9 @@ void DeviceCloudPolicyInvalidator::TryToCreateInvalidator() {
            it != profile_invalidation_service_observers_.end(); ++it) {
     if ((*it)->IsServiceConnected()) {
       // If a connected invalidation service belonging to an affiliated
-      // logged-in user is found, create a |CloudPolicyInvalidator| backed by
-      // that service and destroy the device-global service, if any.
+      // logged-in user is found, make it available to consumers.
       DestroyDeviceInvalidationService();
-      CreateInvalidator((*it)->GetInvalidationService());
+      SetInvalidationService((*it)->GetInvalidationService());
       return;
     }
   }
@@ -252,39 +309,29 @@ void DeviceCloudPolicyInvalidator::TryToCreateInvalidator() {
   }
 
   if (device_invalidation_service_observer_->IsServiceConnected()) {
-    // If the device-global invalidation service is connected, create a
-    // |CloudPolicyInvalidator| backed by it. Otherwise,  a
-    // |CloudPolicyInvalidator| will be created later when a connected service
-    // becomes available.
-    CreateInvalidator(device_invalidation_service_.get());
+    // If the device-global invalidation service is connected, make it available
+    // to consumers. Otherwise, the invalidation service will be made available
+    // later, if and when it successfully connects.
+    SetInvalidationService(device_invalidation_service_.get());
   }
 }
 
-void DeviceCloudPolicyInvalidator::CreateInvalidator(
+void AffiliatedInvalidationServiceProvider::SetInvalidationService(
     invalidation::InvalidationService* invalidation_service) {
+  DCHECK(!invalidation_service_);
   invalidation_service_ = invalidation_service;
-  DCHECK(!invalidator_);
-  invalidator_.reset(new CloudPolicyInvalidator(
-      enterprise_management::DeviceRegisterRequest::DEVICE,
-      g_browser_process->platform_part()->browser_policy_connector_chromeos()->
-          GetDeviceCloudPolicyManager()->core(),
-      base::MessageLoopProxy::current(),
-      scoped_ptr<base::Clock>(new base::DefaultClock()),
-      highest_handled_invalidation_version_));
-  invalidator_->Initialize(invalidation_service);
+    FOR_EACH_OBSERVER(Consumer,

[Mattias Nissler (ping if slow), 2015/01/13 09:50:15]

nit: indentation

[bartfab (slow), 2015/01/13 17:45:23]

Done.

+                      consumers_,
+                      OnInvalidationServiceSet(invalidation_service_));
 }
 
-void DeviceCloudPolicyInvalidator::DestroyInvalidator() {
-  if (invalidator_) {
-    highest_handled_invalidation_version_ =
-        invalidator_->highest_handled_invalidation_version();
-    invalidator_->Shutdown();
-  }
-  invalidator_.reset();
-  invalidation_service_ = NULL;
+void AffiliatedInvalidationServiceProvider::ResetInvalidationService() {
+  if (invalidation_service_)
+    FOR_EACH_OBSERVER(Consumer, consumers_, OnInvalidationServiceReset());
+  invalidation_service_ = nullptr;
 }
 
-void DeviceCloudPolicyInvalidator::DestroyDeviceInvalidationService() {
+void AffiliatedInvalidationServiceProvider::DestroyDeviceInvalidationService() {
   device_invalidation_service_observer_.reset();
   device_invalidation_service_.reset();
 }