Extract DependencyGraph from ProfileDependencyManager.

chrome/browser/profiles/profile_dependency_manager.cc

 // Copyright (c) 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/profiles/profile_dependency_manager.h"
 
 #include <algorithm>
 #include <deque>
 #include <iterator>
 
@@ skipping 113 matching lines @@
 #ifndef NDEBUG
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "chrome/common/chrome_switches.h"
 #endif
 
 class Profile;
 
 void ProfileDependencyManager::AddComponent(
     ProfileKeyedBaseFactory* component) {
-  all_components_.push_back(component);
-  destruction_order_.clear();
+  dependency_graph_.AddNode(component);
 }
 
 void ProfileDependencyManager::RemoveComponent(
     ProfileKeyedBaseFactory* component) {
-  all_components_.erase(std::remove(all_components_.begin(),
-                                    all_components_.end(),
-                                    component),
-                        all_components_.end());
-
-  // Remove all dependency edges that contain this component.
-  EdgeMap::iterator it = edges_.begin();
-  while (it != edges_.end()) {
-    EdgeMap::iterator temp = it;
-    ++it;
-
-    if (temp->first == component || temp->second == component)
-      edges_.erase(temp);
-  }
-
-  destruction_order_.clear();
+  dependency_graph_.RemoveNode(component);
 }
 
 void ProfileDependencyManager::AddEdge(ProfileKeyedBaseFactory* depended,
                                        ProfileKeyedBaseFactory* dependee) {
-  edges_.insert(std::make_pair(depended, dependee));
-  destruction_order_.clear();
+  dependency_graph_.AddEdge(depended, dependee);
 }
 
 void ProfileDependencyManager::CreateProfileServices(Profile* profile,
                                                      bool is_testing_profile) {
 #ifndef NDEBUG
   // Unmark |profile| as dead. This exists because of unit tests, which will
   // often have similar stack structures. 0xWhatever might be created, go out
   // of scope, and then a new Profile object might be created at 0xWhatever.
   dead_profile_pointers_.erase(profile);
 #endif
 
   AssertFactoriesBuilt();
 
-  if (destruction_order_.empty())
-    BuildDestructionOrder(profile);
+  std::vector<DependencyNode*> construction_order;
+  if (!dependency_graph_.GetConstructionOrder(&construction_order)) {
+    NOTREACHED();
+  }
 
-  // Iterate in reverse destruction order for creation.
-  for (std::vector<ProfileKeyedBaseFactory*>::reverse_iterator rit =
-           destruction_order_.rbegin(); rit != destruction_order_.rend();
-       ++rit) {
+#ifndef NDEBUG
+  DumpProfileDependencies(profile);
+#endif
+
+  for (size_t i = 0; i < construction_order.size(); i++) {
+    ProfileKeyedBaseFactory* factory =
+        static_cast<ProfileKeyedBaseFactory*>(construction_order[i]);
+
     if (!profile->IsOffTheRecord()) {
       // We only register preferences on normal profiles because the incognito
       // profile shares the pref service with the normal one.
-      (*rit)->RegisterUserPrefsOnProfile(profile);
+      factory->RegisterUserPrefsOnProfile(profile);
     }
 
-    if (is_testing_profile && (*rit)->ServiceIsNULLWhileTesting()) {
-      (*rit)->SetEmptyTestingFactory(profile);
-    } else if ((*rit)->ServiceIsCreatedWithProfile()) {
+    if (is_testing_profile && factory->ServiceIsNULLWhileTesting()) {
+      factory->SetEmptyTestingFactory(profile);
+    } else if (factory->ServiceIsCreatedWithProfile()) {
       // Create the service.
-      (*rit)->CreateServiceNow(profile);
+      factory->CreateServiceNow(profile);
     }
   }
 }
 
 void ProfileDependencyManager::DestroyProfileServices(Profile* profile) {
-  if (destruction_order_.empty())
-    BuildDestructionOrder(profile);
-
-  for (std::vector<ProfileKeyedBaseFactory*>::const_iterator it =
-           destruction_order_.begin(); it != destruction_order_.end(); ++it) {
-    (*it)->ProfileShutdown(profile);
+  std::vector<DependencyNode*> destruction_order;
+  if (!dependency_graph_.GetDestructionOrder(&destruction_order)) {
+    NOTREACHED();
   }
 
 #ifndef NDEBUG
+  DumpProfileDependencies(profile);
+#endif
+
+  for (size_t i = 0; i < destruction_order.size(); i++) {
+    ProfileKeyedBaseFactory* factory =
+        static_cast<ProfileKeyedBaseFactory*>(destruction_order[i]);
+    factory->ProfileShutdown(profile);
+  }
+
+#ifndef NDEBUG
   // The profile is now dead to the rest of the program.
   dead_profile_pointers_.insert(profile);
 #endif
 
-  for (std::vector<ProfileKeyedBaseFactory*>::const_iterator it =
-           destruction_order_.begin(); it != destruction_order_.end(); ++it) {
-    (*it)->ProfileDestroyed(profile);
+  for (size_t i = 0; i < destruction_order.size(); i++) {
+    ProfileKeyedBaseFactory* factory =
+        static_cast<ProfileKeyedBaseFactory*>(destruction_order[i]);
+    factory->ProfileDestroyed(profile);
   }
 }
 
 #ifndef NDEBUG
 void ProfileDependencyManager::AssertProfileWasntDestroyed(Profile* profile) {
   if (dead_profile_pointers_.find(profile) != dead_profile_pointers_.end()) {
     NOTREACHED() << "Attempted to access a Profile that was ShutDown(). This "
                  << "is most likely a heap smasher in progress. After "
                  << "ProfileKeyedService::Shutdown() completes, your service "
                  << "MUST NOT refer to depended Profile services again.";
   }
 }
 #endif
 
 // static
 ProfileDependencyManager* ProfileDependencyManager::GetInstance() {
   return Singleton<ProfileDependencyManager>::get();
 }
 
+namespace {
+
+std::string ProfileKeyedBaseFactoryGetNodeName(DependencyNode* node) {
+  return static_cast<ProfileKeyedBaseFactory*>(node)->name();
+}
+
+}  // namespace
+
 ProfileDependencyManager::ProfileDependencyManager()
-    : built_factories_(false) {
+    : built_factories_(false),
+      dependency_graph_(base::Bind(&ProfileKeyedBaseFactoryGetNodeName)) {
 }
 
 ProfileDependencyManager::~ProfileDependencyManager() {}
 
 // This method gets the instance of each ServiceFactory. We do this so that
 // each ServiceFactory initializes itself and registers its dependencies with
 // the global PreferenceDependencyManager. We need to have a complete
 // dependency graph when we create a profile so we can dispatch the profile
 // creation message to the services that want to create their services at
 // profile creation time.
@@ skipping 134 matching lines @@
   ThemeServiceFactory::GetInstance();
 #endif
   TokenCacheServiceFactory::GetInstance();
   TokenServiceFactory::GetInstance();
   UserStyleSheetWatcherFactory::GetInstance();
   WebDataServiceFactory::GetInstance();
 
   built_factories_ = true;
 }
 
-void ProfileDependencyManager::BuildDestructionOrder(Profile* profile) {
-#if !defined(NDEBUG)
+#ifndef NDEBUG
+void ProfileDependencyManager::DumpProfileDependencies(Profile* profile) {
   // Whenever we try to build a destruction ordering, we should also dump a
   // dependency graph to "/path/to/profile/profile-dependencies.dot".
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDumpProfileDependencyGraph)) {
     base::FilePath dot_file =
         profile->GetPath().AppendASCII("profile-dependencies.dot");
-    std::string contents = DumpGraphvizDependency();
+    std::string contents = dependency_graph_.DumpAsGraphviz("Profile");
     file_util::WriteFile(dot_file, contents.c_str(), contents.size());
   }
+}
 #endif
-
-  // Step 1: Build a set of nodes with no incoming edges.
-  std::deque<ProfileKeyedBaseFactory*> queue;
-  std::copy(all_components_.begin(),
-            all_components_.end(),
-            std::back_inserter(queue));
-
-  std::deque<ProfileKeyedBaseFactory*>::iterator queue_end = queue.end();
-  for (EdgeMap::const_iterator it = edges_.begin();
-       it != edges_.end(); ++it) {
-    queue_end = std::remove(queue.begin(), queue_end, it->second);
-  }
-  queue.erase(queue_end, queue.end());
-
-  // Step 2: Do the Kahn topological sort.
-  std::vector<ProfileKeyedBaseFactory*> output;
-  EdgeMap edges(edges_);
-  while (!queue.empty()) {
-    ProfileKeyedBaseFactory* node = queue.front();
-    queue.pop_front();
-    output.push_back(node);
-
-    std::pair<EdgeMap::iterator, EdgeMap::iterator> range =
-        edges.equal_range(node);
-    EdgeMap::iterator it = range.first;
-    while (it != range.second) {
-      ProfileKeyedBaseFactory* dest = it->second;
-      EdgeMap::iterator temp = it;
-      it++;
-      edges.erase(temp);
-
-      bool has_incoming_edges = false;
-      for (EdgeMap::iterator jt = edges.begin(); jt != edges.end(); ++jt) {
-        if (jt->second == dest) {
-          has_incoming_edges = true;
-          break;
-        }
-      }
-
-      if (!has_incoming_edges)
-        queue.push_back(dest);
-    }
-  }
-
-  if (edges.size()) {
-    NOTREACHED() << "Dependency graph has a cycle. We are doomed.";
-  }
-
-  std::reverse(output.begin(), output.end());
-  destruction_order_ = output;
-}
-
-#if !defined(NDEBUG)
-
-std::string ProfileDependencyManager::DumpGraphvizDependency() {
-  std::string result("digraph {\n");
-
-  // Make a copy of all components.
-  std::deque<ProfileKeyedBaseFactory*> components;
-  std::copy(all_components_.begin(),
-            all_components_.end(),
-            std::back_inserter(components));
-
-  // State all dependencies and remove |second| so we don't generate an
-  // implicit dependency on the Profile hard coded node.
-  std::deque<ProfileKeyedBaseFactory*>::iterator components_end =
-      components.end();
-  result.append("  /* Dependencies */\n");
-  for (EdgeMap::const_iterator it = edges_.begin(); it != edges_.end(); ++it) {
-    result.append("  ");
-    result.append(it->second->name());
-    result.append(" -> ");
-    result.append(it->first->name());
-    result.append(";\n");
-
-    components_end = std::remove(components.begin(), components_end,
-                                 it->second);
-  }
-  components.erase(components_end, components.end());
-
-  // Every node that doesn't depend on anything else will implicitly depend on
-  // the Profile.
-  result.append("\n  /* Toplevel attachments */\n");
-  for (std::deque<ProfileKeyedBaseFactory*>::const_iterator it =
-           components.begin(); it != components.end(); ++it) {
-    result.append("  ");
-    result.append((*it)->name());
-    result.append(" -> Profile;\n");
-  }
-
-  result.append("\n  /* Toplevel profile */\n");
-  result.append("  Profile [shape=box];\n");
-
-  result.append("}\n");
-  return result;
-}
-
-#endif