[Sync] Move some extension-sync-related logic to ExtensionService

chrome/browser/sync/glue/extension_change_processor.cc

 // Copyright (c) 2011 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_change_processor.h"
 
 #include <sstream>
 #include <string>
 
 #include "base/logging.h"
 #include "base/stl_util-inl.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_sync_data.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/glue/extension_sync.h"
 #include "chrome/browser/sync/glue/extension_util.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/protocol/extension_specifics.pb.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/browser/browser_thread.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_source.h"
 
@@ skipping 71 matching lines @@
 void ExtensionChangeProcessor::ApplyChangesFromSyncModel(
     const sync_api::BaseTransaction* trans,
     const sync_api::SyncManager::ChangeRecord* changes,
     int change_count) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!running()) {
     return;
   }
   for (int i = 0; i < change_count; ++i) {
     const sync_api::SyncManager::ChangeRecord& change = changes[i];
+    sync_pb::ExtensionSpecifics specifics;
     switch (change.action) {
       case sync_api::SyncManager::ChangeRecord::ACTION_ADD:
       case sync_api::SyncManager::ChangeRecord::ACTION_UPDATE: {
         sync_api::ReadNode node(trans);
         if (!node.InitByIdLookup(change.id)) {
           std::stringstream error;
           error << "Extension node lookup failed for change " << change.id
                 << " of action type " << change.action;
           error_handler()->OnUnrecoverableError(FROM_HERE, error.str());
           return;
         }
         DCHECK_EQ(node.GetModelType(), traits_.model_type);
-        const sync_pb::ExtensionSpecifics& specifics =
-            (*traits_.extension_specifics_getter)(node);
-        if (!IsExtensionSpecificsValid(specifics)) {
-          std::string error =
-              std::string("Invalid server specifics: ") +
-              ExtensionSpecificsToString(specifics);
-          error_handler()->OnUnrecoverableError(FROM_HERE, error);
-          return;
-        }
-        StopObserving();
-        UpdateClient(traits_, specifics, extension_service_);
-        StartObserving();
+        specifics = (*traits_.extension_specifics_getter)(node);
         break;
       }
       case sync_api::SyncManager::ChangeRecord::ACTION_DELETE: {
-        sync_pb::ExtensionSpecifics specifics;
-        if ((*traits_.extension_specifics_entity_getter)(
+        if (!(*traits_.extension_specifics_entity_getter)(
                 change.specifics, &specifics)) {
-          StopObserving();
-          RemoveFromClient(traits_, specifics.id(), extension_service_);
-          StartObserving();
-        } else {
           std::stringstream error;
-          error << "Could not get extension ID for deleted node "
+          error << "Could not get extension specifics from deleted node "
                 << change.id;
           error_handler()->OnUnrecoverableError(FROM_HERE, error.str());
           LOG(DFATAL) << error.str();
         }
         break;
       }
     }
+    ExtensionSyncData sync_data;
+    if (!GetExtensionSyncData(specifics, &sync_data)) {
+      // TODO(akalin): Should probably recover or drop.
+      std::string error =
+          std::string("Invalid server specifics: ") +
+          ExtensionSpecificsToString(specifics);
+      error_handler()->OnUnrecoverableError(FROM_HERE, error);
+      return;
+    }
+    sync_data.uninstalled =
+        (change.action == sync_api::SyncManager::ChangeRecord::ACTION_DELETE);
+    StopObserving();
+    extension_service_->ProcessSyncData(sync_data,
+                                        traits_.is_valid_and_syncable);
+    StartObserving();
   }
 }
 
 void ExtensionChangeProcessor::StartImpl(Profile* profile) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   profile_ = profile;
   extension_service_ = profile_->GetExtensionService();
   user_share_ = profile_->GetProfileSyncService()->GetUserShare();
   DCHECK(profile_);
   DCHECK(extension_service_);
@@ skipping 34 matching lines @@
 }
 
 void ExtensionChangeProcessor::StopObserving() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(profile_);
   VLOG(1) << "Unobserving all notifications";
   notification_registrar_.RemoveAll();
 }
 
 }  // namespace browser_sync