Fix policy invalidator lifecycle bugs for Android.

chrome/browser/policy/cloud/user_cloud_policy_invalidator.cc

 // Copyright 2013 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/policy/cloud/user_cloud_policy_invalidator.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/policy/cloud/cloud_policy_core.h"
+#include "chrome/browser/invalidation/invalidation_service_factory.h"
 #include "chrome/browser/policy/cloud/cloud_policy_manager.h"
 #include "content/public/browser/notification_source.h"
 
 namespace policy {
 
 UserCloudPolicyInvalidator::UserCloudPolicyInvalidator(
     Profile* profile,
     CloudPolicyManager* policy_manager)
     : CloudPolicyInvalidator(
-          policy_manager,
-          policy_manager->core()->store(),
+          policy_manager->core(),
           base::MessageLoopProxy::current()),
-      profile_(profile),
-      policy_manager_(policy_manager) {
+      profile_(profile) {
   DCHECK(profile);
 
-  // Register for notification that profile creation is complete.
+  // Register for notification that profile creation is complete. The
+  // invalidator must not be initialized before then because the invalidation
+  // service cannot be started because it depends on components initialized
+  // after this object is instantiated.

[Mattias Nissler (ping if slow), 2013/09/02 11:54:52]

What are those? Shouldn't they be declared as dependencies of
InvalidationService then?

[Steve Condie, 2013/09/03 04:41:56]

SSLConfigServiceManager::CreateDefaultManager must run. This is called during
ProfileImpl::DoFinalInit. Since all profile-keyed services are instantiated
before that, I don't see any way to declare that as a dependency to delay
instantiation. The best way I can see to be notified when that is ready is to
wait for the PROFILE_ADDED event (this was the solution suggested by Joao during
the initial code review; he said the same strategy is used in a couple other
places in the policy code).

   registrar_.Add(this,
                  chrome::NOTIFICATION_PROFILE_ADDED,
                  content::Source<Profile>(profile));
 }
 
 void UserCloudPolicyInvalidator::Shutdown() {
   CloudPolicyInvalidator::Shutdown();
 }
 
 void UserCloudPolicyInvalidator::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  // Enable invalidations now that profile creation is complete.
+  // Initialize now that profile creation is complete and the invalidation
+  // service can safely be initialized.
   DCHECK(type == chrome::NOTIFICATION_PROFILE_ADDED);
-  policy_manager_->EnableInvalidations(
-      base::Bind(
-          &CloudPolicyInvalidator::InitializeWithProfile,
-          GetWeakPtr(),
-          base::Unretained(profile_)));
+  Initialize(base::Bind(
+      &invalidation::InvalidationServiceFactory::GetForProfile,
+      base::Unretained(profile_)));
 }
 
 }  // namespace policy