Rename ExtensionsService to ExtensionService.

chrome/browser/sync/glue/extension_sync.cc

 // 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.
 
 #include "chrome/browser/sync/glue/extension_sync.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "chrome/browser/extensions/extension_updater.h"
-#include "chrome/browser/extensions/extensions_service.h"
+#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/glue/extension_data.h"
 #include "chrome/browser/sync/glue/extension_sync_traits.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 
 namespace browser_sync {
 
 bool RootNodeHasChildren(const char* tag,
                          ProfileSyncService* sync_service,
                          bool* has_children) {
   CHECK(has_children);
   *has_children = false;
   sync_api::ReadTransaction trans(
       sync_service->backend()->GetUserShareHandle());
   sync_api::ReadNode node(&trans);
   if (!node.InitByTagLookup(tag)) {
     LOG(ERROR) << "Root node with tag " << tag << " does not exist";
     return false;
   }
   *has_children = node.GetFirstChildId() != sync_api::kInvalidId;
   return true;
 }
 
-ExtensionsService* GetExtensionsServiceFromProfile(
+ExtensionService* GetExtensionServiceFromProfile(
     Profile* profile) {
   CHECK(profile);
-  ExtensionsService* extensions_service = profile->GetExtensionsService();
+  ExtensionService* extensions_service = profile->GetExtensionService();
   CHECK(extensions_service);
   return extensions_service;
 }
 
 namespace {
 
-ExtensionsService* GetExtensionsServiceFromProfileSyncService(
+ExtensionService* GetExtensionServiceFromProfileSyncService(
     ProfileSyncService* sync_service) {
   CHECK(sync_service);
-  return GetExtensionsServiceFromProfile(sync_service->profile());
+  return GetExtensionServiceFromProfile(sync_service->profile());
 }
 
 // Updates the value in |extension_data_map| from the given data,
 // creating an entry if necessary.  Returns a pointer to the
 // updated/created ExtensionData object.
 ExtensionData* SetOrCreateExtensionData(
     ExtensionDataMap* extension_data_map,
     ExtensionData::Source source,
     bool merge_user_properties,
     const sync_pb::ExtensionSpecifics& data) {
@@ skipping 13 matching lines @@
   }
   return extension_data;
 }
 
 // Reads the client data for each extension in |extensions| to be
 // synced and updates |extension_data_map|.  Puts all unsynced
 // extensions in |unsynced_extensions|.
 void ReadClientDataFromExtensionList(
     const ExtensionList& extensions,
     const ExtensionTypeSet& allowed_extension_types,
-    ExtensionsService* extensions_service,
+    ExtensionService* extensions_service,
     std::set<std::string>* unsynced_extensions,
     ExtensionDataMap* extension_data_map) {
   for (ExtensionList::const_iterator it = extensions.begin();
        it != extensions.end(); ++it) {
     CHECK(*it);
     const Extension& extension = **it;
     if (IsExtensionValidAndSyncable(extension, allowed_extension_types)) {
       sync_pb::ExtensionSpecifics client_specifics;
       GetExtensionSpecifics(extension, extensions_service->extension_prefs(),
                             &client_specifics);
       DcheckIsExtensionSpecificsValid(client_specifics);
       const ExtensionData& extension_data =
           *SetOrCreateExtensionData(
               extension_data_map, ExtensionData::CLIENT,
               true, client_specifics);
       DcheckIsExtensionSpecificsValid(extension_data.merged_data());
       // Assumes this is called before any server data is read.
       DCHECK(extension_data.NeedsUpdate(ExtensionData::SERVER));
       DCHECK(!extension_data.NeedsUpdate(ExtensionData::CLIENT));
     } else {
       unsynced_extensions->insert(extension.id());
     }
   }
 }
 
 // Simply calls ReadClientDataFromExtensionList() on the list of
 // enabled and disabled extensions from |extensions_service|.
 void SlurpClientData(
     const ExtensionTypeSet& allowed_extension_types,
-    ExtensionsService* extensions_service,
+    ExtensionService* extensions_service,
     std::set<std::string>* unsynced_extensions,
     ExtensionDataMap* extension_data_map) {
   const ExtensionList* extensions = extensions_service->extensions();
   CHECK(extensions);
   ReadClientDataFromExtensionList(
       *extensions, allowed_extension_types, extensions_service,
       unsynced_extensions, extension_data_map);
 
   const ExtensionList* disabled_extensions =
       extensions_service->disabled_extensions();
@@ skipping 60 matching lines @@
     id = sync_node.GetSuccessorId();
   }
   return true;
 }
 
 }  // namespace
 
 bool SlurpExtensionData(const ExtensionSyncTraits& traits,
                         ProfileSyncService* sync_service,
                         ExtensionDataMap* extension_data_map) {
-  ExtensionsService* extensions_service =
-      GetExtensionsServiceFromProfileSyncService(sync_service);
+  ExtensionService* extensions_service =
+      GetExtensionServiceFromProfileSyncService(sync_service);
   std::set<std::string> unsynced_extensions;
 
   // Read client-side data first so server data takes precedence, and
   // also so we have an idea of which extensions are unsyncable.
   SlurpClientData(
       traits.allowed_extension_types, extensions_service,
       &unsynced_extensions, extension_data_map);
 
   if (!SlurpServerData(
           traits.root_node_tag, traits.extension_specifics_getter,
@@ skipping 47 matching lines @@
 // Tries to update the client data from the given extension data.
 // extension_data->ServerNeedsUpdate() must not hold and
 // extension_data->ClientNeedsUpdate() must hold before this function
 // is called.  If the update was successful,
 // extension_data->ClientNeedsUpdate() will be false after this
 // function is called.  Otherwise, the extension needs updating to a
 // new version.
 void TryUpdateClient(
     const ExtensionTypeSet& allowed_extension_types,
     PendingExtensionInfo::ExpectedCrxType expected_crx_type,
-    ExtensionsService* extensions_service,
+    ExtensionService* extensions_service,
     ExtensionData* extension_data) {
   DCHECK(!extension_data->NeedsUpdate(ExtensionData::SERVER));
   DCHECK(extension_data->NeedsUpdate(ExtensionData::CLIENT));
   const sync_pb::ExtensionSpecifics& specifics =
       extension_data->merged_data();
   DcheckIsExtensionSpecificsValid(specifics);
   const std::string& id = specifics.id();
   const Extension* extension = extensions_service->GetExtensionById(id, true);
   if (extension) {
     if (!IsExtensionValidAndSyncable(*extension, allowed_extension_types)) {
@@ skipping 26 matching lines @@
         specifics.enabled(),
         specifics.incognito_enabled());
   }
   DCHECK(!extension_data->NeedsUpdate(ExtensionData::SERVER));
 }
 
 // Kick off a run of the extension updater.
 //
 // TODO(akalin): Combine this with the similar function in
 // theme_util.cc.
-void NudgeExtensionUpdater(ExtensionsService* extensions_service) {
+void NudgeExtensionUpdater(ExtensionService* extensions_service) {
   ExtensionUpdater* extension_updater = extensions_service->updater();
   // Auto-updates should now be on always (see the construction of the
-  // ExtensionsService in ProfileImpl::InitExtensions()).
+  // ExtensionService in ProfileImpl::InitExtensions()).
   if (extension_updater) {
     extension_updater->CheckNow();
   } else {
     LOG(DFATAL) << "Extension updater unexpectedly NULL; "
                 << "auto-updates may be turned off";
   }
 }
 
 }  // namespace
 
 bool FlushExtensionData(const ExtensionSyncTraits& traits,
                         const ExtensionDataMap& extension_data_map,
                         ProfileSyncService* sync_service) {
   sync_api::WriteTransaction trans(
       sync_service->backend()->GetUserShareHandle());
   sync_api::ReadNode root(&trans);
   if (!root.InitByTagLookup(traits.root_node_tag)) {
     LOG(ERROR) << GetRootNodeDoesNotExistError(traits.root_node_tag);
     return false;
   }
 
-  ExtensionsService* extensions_service =
-      GetExtensionsServiceFromProfileSyncService(sync_service);
+  ExtensionService* extensions_service =
+      GetExtensionServiceFromProfileSyncService(sync_service);
 
   // Update server and client as necessary.
   bool should_nudge_extension_updater = false;
   for (ExtensionDataMap::const_iterator it = extension_data_map.begin();
        it != extension_data_map.end(); ++it) {
     ExtensionData extension_data = it->second;
     // Update server first.
     if (extension_data.NeedsUpdate(ExtensionData::SERVER)) {
       if (!UpdateServer(traits, &extension_data, &trans)) {
         LOG(ERROR) << "Could not update server data for extension "
@@ skipping 27 matching lines @@
   const std::string& id = extension.id();
   if (!IsExtensionValidAndSyncable(extension,
                                    traits.allowed_extension_types)) {
     *error =
         std::string("UpdateServerData() called for invalid or "
                     "unsyncable extension ") + id;
     LOG(DFATAL) << *error;
     return false;
   }
 
-  ExtensionsService* extensions_service =
-      GetExtensionsServiceFromProfileSyncService(sync_service);
+  ExtensionService* extensions_service =
+      GetExtensionServiceFromProfileSyncService(sync_service);
   sync_pb::ExtensionSpecifics client_data;
   GetExtensionSpecifics(extension, extensions_service->extension_prefs(),
                         &client_data);
   DcheckIsExtensionSpecificsValid(client_data);
   ExtensionData extension_data =
       ExtensionData::FromData(ExtensionData::CLIENT, client_data);
 
   sync_api::WriteTransaction trans(
       sync_service->backend()->GetUserShareHandle());
 
@@ skipping 39 matching lines @@
   sync_api::WriteNode write_node(&trans);
   if (write_node.InitByClientTagLookup(traits.model_type, id)) {
     write_node.Remove();
   } else {
     LOG(ERROR) << "Server data does not exist for extension " << id;
   }
 }
 
 void UpdateClient(const ExtensionSyncTraits& traits,
                   const sync_pb::ExtensionSpecifics& server_data,
-                  ExtensionsService* extensions_service) {
+                  ExtensionService* extensions_service) {
   DcheckIsExtensionSpecificsValid(server_data);
   ExtensionData extension_data =
       ExtensionData::FromData(ExtensionData::SERVER, server_data);
   const Extension* extension =
       extensions_service->GetExtensionById(server_data.id(), true);
   if (extension) {
     if (!IsExtensionValidAndSyncable(
             *extension, traits.allowed_extension_types)) {
       LOG(WARNING) << "Ignoring server data for invalid or "
                    << "non-syncable extension " << extension->id();
@@ skipping 14 matching lines @@
                     extensions_service, &extension_data);
     if (extension_data.NeedsUpdate(ExtensionData::CLIENT)) {
       NudgeExtensionUpdater(extensions_service);
     }
   }
   DCHECK(!extension_data.NeedsUpdate(ExtensionData::SERVER));
 }
 
 void RemoveFromClient(const ExtensionSyncTraits& traits,
                       const std::string& id,
-                      ExtensionsService* extensions_service) {
+                      ExtensionService* extensions_service) {
   const Extension* extension = extensions_service->GetExtensionById(id, true);
   if (extension) {
     if (IsExtensionValidAndSyncable(*extension,
                                     traits.allowed_extension_types)) {
       extensions_service->UninstallExtension(id, false);
     } else {
       LOG(WARNING) << "Ignoring server data for invalid or "
                    << "non-syncable extension " << extension->id();
     }
   } else {
     LOG(ERROR) << "Trying to uninstall nonexistent extension " << id;
   }
 }
 
 }  // namespace browser_sync