Added checks to handle unsyncable extensions.

chrome/browser/sync/glue/extension_change_processor.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_change_processor.h"
 
 #include <sstream>
 #include <string>
 
 #include "base/logging.h"
 #include "chrome/browser/chrome_thread.h"
+#include "chrome/browser/extensions/extensions_service.h"
+#include "chrome/browser/profile.h"
 #include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/glue/extension_model_associator.h"
 #include "chrome/browser/sync/glue/extension_util.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/notification_details.h"
 #include "chrome/common/notification_source.h"
 
 namespace browser_sync {
 
 ExtensionChangeProcessor::ExtensionChangeProcessor(
@@ skipping 22 matching lines @@
   DCHECK(running());
   DCHECK(profile_);
   switch (type.value) {
     case NotificationType::EXTENSION_LOADED:
     case NotificationType::EXTENSION_UPDATE_DISABLED:
     case NotificationType::EXTENSION_UNLOADED:
     case NotificationType::EXTENSION_UNLOADED_DISABLED: {
       DCHECK_EQ(Source<Profile>(source).ptr(), profile_);
       Extension* extension = Details<Extension>(details).ptr();
       CHECK(extension);
+      // Ignore non-syncable extensions.
       if (!IsExtensionSyncable(*extension)) {
         return;
       }
       const std::string& id = extension->id();
       LOG(INFO) << "Got change notification of type " << type.value
                 << " for extension " << id;
       if (!extension_model_associator_->OnClientUpdate(id)) {
         std::string error = std::string("Client update failed for ") + id;
         error_handler()->OnUnrecoverableError(FROM_HERE, error);
         return;
@@ skipping 31 matching lines @@
         DCHECK_EQ(node.GetModelType(), syncable::EXTENSIONS);
         const sync_pb::ExtensionSpecifics& specifics =
             node.GetExtensionSpecifics();
         if (!IsExtensionSpecificsValid(specifics)) {
           std::string error =
               std::string("Invalid server specifics: ") +
               ExtensionSpecificsToString(specifics);
           error_handler()->OnUnrecoverableError(FROM_HERE, error);
           return;
         }
+        const std::string& id = specifics.id();
+        CHECK(profile_);
+        ExtensionsService* extensions_service =
+            profile_->GetExtensionsService();
+        CHECK(extensions_service);
+        Extension* extension =
+            extensions_service->GetExtensionById(id, true);
+        if (extension && !IsExtensionSyncable(*extension)) {
+          LOG(WARNING) << "Not updating unsyncable extension " << id;
+          return;
+        }
         StopObserving();
-        extension_model_associator_->OnServerUpdate(specifics);
+        extension_model_associator_->OnServerUpdate(specifics, extension);
         StartObserving();
         break;
       }
       case sync_api::SyncManager::ChangeRecord::ACTION_DELETE: {
-        StopObserving();
-        if (change.specifics.HasExtension(sync_pb::extension)) {
-          extension_model_associator_->OnServerRemove(
-              change.specifics.GetExtension(sync_pb::extension).id());
-        } else {
+        if (!change.specifics.HasExtension(sync_pb::extension)) {
           std::stringstream error;
-          error << "Could not get extension ID for deleted node "
+          error << "Could not get extension ID for delete node "
                 << change.id;
           error_handler()->OnUnrecoverableError(FROM_HERE, error.str());
           LOG(DFATAL) << error.str();
+          return;
         }
+        const std::string& id =
+            change.specifics.GetExtension(sync_pb::extension).id();
+        CHECK(profile_);
+        ExtensionsService* extensions_service =
+            profile_->GetExtensionsService();
+        CHECK(extensions_service);
+        Extension* extension =
+            extensions_service->GetExtensionById(id, true);
+        if (!extension) {
+          LOG(ERROR) << "Trying to uninstall nonexistent extension " << id
+                     << " for delete node " << change.id;
+          return;
+        }
+        if (!IsExtensionSyncable(*extension)) {
+          LOG(WARNING) << "Not uninstalling unsyncable extension " << id
+                       << " for delete node " << change.id;
+          return;
+        }
+        StopObserving();
+        extensions_service->UninstallExtension(id, false);
         StartObserving();
         break;
       }
     }
   }
 }
 
 void ExtensionChangeProcessor::StartImpl(Profile* profile) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   DCHECK(profile);
@@ skipping 32 matching lines @@
 }
 
 void ExtensionChangeProcessor::StopObserving() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   DCHECK(profile_);
   LOG(INFO) << "Unobserving all notifications";
   notification_registrar_.RemoveAll();
 }
 
 }  // namespace browser_sync