Merge 53127 - Added checks to handle unsyncable extensions....

chrome/browser/sync/glue/extension_model_associator.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_model_associator.h"
 
 #include <map>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 37 matching lines @@
     DCHECK(!extension_data->NeedsUpdate(source));
   } else {
     extension_data->SetData(source, merge_user_properties, data);
   }
   return extension_data;
 }
 
 void GetSyncableExtensionsClientData(
     const ExtensionList& extensions,
     ExtensionsService* extensions_service,
+    std::set<std::string>* unsyncable_extensions,
     ExtensionDataMap* extension_data_map) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   for (ExtensionList::const_iterator it = extensions.begin();
        it != extensions.end(); ++it) {
     CHECK(*it);
     const Extension& extension = **it;
     if (IsExtensionSyncable(extension)) {
       sync_pb::ExtensionSpecifics client_specifics;
       GetExtensionSpecifics(extension, extensions_service,
                             &client_specifics);
       DcheckIsExtensionSpecificsValid(client_specifics);
       const ExtensionData& extension_data =
           *SetOrCreateData(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 {
+      unsyncable_extensions->insert(extension.id());
     }
   }
 }
 
 }  // namespace
 
 ExtensionModelAssociator::ExtensionModelAssociator(
     ProfileSyncService* sync_service) : sync_service_(sync_service) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   DCHECK(sync_service_);
 }
 
 ExtensionModelAssociator::~ExtensionModelAssociator() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 }
 
 bool ExtensionModelAssociator::AssociateModels() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   sync_api::WriteTransaction trans(
       sync_service_->backend()->GetUserShareHandle());
   sync_api::ReadNode root(&trans);
   if (!root.InitByTagLookup(kExtensionsTag)) {
     LOG(ERROR) << kNoExtensionsFolderError;
     return false;
   }
 
+  std::set<std::string> unsyncable_extensions;
   ExtensionDataMap extension_data_map;
 
   // Read client-side data.  Do this first so server data takes
   // precedence.
   {
     ExtensionsService* extensions_service = GetExtensionsService();
 
     const ExtensionList* extensions = extensions_service->extensions();
     CHECK(extensions);
     GetSyncableExtensionsClientData(
-        *extensions, extensions_service, &extension_data_map);
+        *extensions, extensions_service,
+        &unsyncable_extensions, &extension_data_map);
 
     const ExtensionList* disabled_extensions =
         extensions_service->disabled_extensions();
     CHECK(disabled_extensions);
     GetSyncableExtensionsClientData(
-        *disabled_extensions, extensions_service, &extension_data_map);
+        *disabled_extensions, extensions_service,
+        &unsyncable_extensions, &extension_data_map);
   }
 
   // Read server-side data.
   {
     int64 id = root.GetFirstChildId();
     while (id != sync_api::kInvalidId) {
       sync_api::ReadNode sync_node(&trans);
       if (!sync_node.InitByIdLookup(id)) {
         LOG(ERROR) << "Failed to fetch sync node for id " << id;
         return false;
       }
       const sync_pb::ExtensionSpecifics& server_data =
           sync_node.GetExtensionSpecifics();
       if (!IsExtensionSpecificsValid(server_data)) {
         LOG(ERROR) << "Invalid extensions specifics for id " << id;
         return false;
       }
-      // Pass in false for merge_user_properties so client user
-      // settings always take precedence.
-      const ExtensionData& extension_data =
-          *SetOrCreateData(&extension_data_map,
-                           ExtensionData::SERVER, false, server_data);
-      DcheckIsExtensionSpecificsValid(extension_data.merged_data());
+      // Don't process server data for extensions we know are
+      // unsyncable.  This doesn't catch everything, as if we don't
+      // have the extension already installed we can't check, but we
+      // also check at extension install time.
+      if (unsyncable_extensions.find(server_data.id()) ==
+          unsyncable_extensions.end()) {
+        // Pass in false for merge_user_properties so client user
+        // settings always take precedence.
+        const ExtensionData& extension_data =
+            *SetOrCreateData(&extension_data_map,
+                             ExtensionData::SERVER, false, server_data);
+        DcheckIsExtensionSpecificsValid(extension_data.merged_data());
+      }
       id = sync_node.GetSuccessorId();
     }
   }
 
   // Update server and client as necessary.
   bool should_nudge_extension_updater = false;
   for (ExtensionDataMap::iterator it = extension_data_map.begin();
        it != extension_data_map.end(); ++it) {
     ExtensionData* extension_data = &it->second;
     // Update server first.
@@ skipping 45 matching lines @@
 }
 
 bool ExtensionModelAssociator::OnClientUpdate(const std::string& id) {
   sync_api::WriteTransaction trans(
       sync_service_->backend()->GetUserShareHandle());
   sync_api::ReadNode root(&trans);
   if (!root.InitByTagLookup(kExtensionsTag)) {
     LOG(ERROR) << kNoExtensionsFolderError;
     return false;
   }
-
-  sync_pb::ExtensionSpecifics client_data;
-  if (GetExtensionDataFromClient(id, &client_data)) {
+  ExtensionsService* extensions_service = GetExtensionsService();
+  Extension* extension = extensions_service->GetExtensionById(id, true);
+  if (extension) {
+    if (!IsExtensionSyncable(*extension)) {
+      LOG(DFATAL) << "OnClientUpdate() called for non-syncable extension "
+                  << id;
+      return false;
+    }
+    sync_pb::ExtensionSpecifics client_data;
+    GetExtensionSpecifics(*extension, extensions_service, &client_data);
+    DcheckIsExtensionSpecificsValid(client_data);
     ExtensionData extension_data =
         ExtensionData::FromData(ExtensionData::CLIENT, client_data);
     sync_pb::ExtensionSpecifics server_data;
     if (GetExtensionDataFromServer(id, &trans, root, &server_data)) {
       extension_data =
           ExtensionData::FromData(ExtensionData::SERVER, server_data);
       extension_data.SetData(ExtensionData::CLIENT, true, client_data);
     }
     if (extension_data.NeedsUpdate(ExtensionData::SERVER)) {
       if (!UpdateServer(&extension_data, &trans, root)) {
@@ skipping 18 matching lines @@
     }
   }
   return true;
 }
 
 void ExtensionModelAssociator::OnServerUpdate(
     const sync_pb::ExtensionSpecifics& server_data) {
   DcheckIsExtensionSpecificsValid(server_data);
   ExtensionData extension_data =
       ExtensionData::FromData(ExtensionData::SERVER, server_data);
-  sync_pb::ExtensionSpecifics client_data;
-  if (GetExtensionDataFromClient(server_data.id(), &client_data)) {
-    ExtensionData extension_data =
+  ExtensionsService* extensions_service = GetExtensionsService();
+  Extension* extension =
+      extensions_service->GetExtensionById(server_data.id(), true);
+  if (extension) {
+    if (!IsExtensionSyncable(*extension)) {
+      // Ignore updates for non-syncable extensions (we may get those
+      // for extensions that were previously syncable).
+      return;
+    }
+    sync_pb::ExtensionSpecifics client_data;
+    GetExtensionSpecifics(*extension, extensions_service, &client_data);
+    DcheckIsExtensionSpecificsValid(client_data);
+    extension_data =
         ExtensionData::FromData(ExtensionData::CLIENT, client_data);
     extension_data.SetData(ExtensionData::SERVER, true, server_data);
   }
   DCHECK(!extension_data.NeedsUpdate(ExtensionData::SERVER));
   if (extension_data.NeedsUpdate(ExtensionData::CLIENT)) {
     TryUpdateClient(&extension_data);
     if (extension_data.NeedsUpdate(ExtensionData::CLIENT)) {
       NudgeExtensionUpdater();
     }
   }
   DCHECK(!extension_data.NeedsUpdate(ExtensionData::SERVER));
 }
 
 void ExtensionModelAssociator::OnServerRemove(const std::string& id) {
   ExtensionsService* extensions_service = GetExtensionsService();
   Extension* extension = extensions_service->GetExtensionById(id, true);
   if (extension) {
-    extensions_service->UninstallExtension(id, false);
+    if (IsExtensionSyncable(*extension)) {
+      extensions_service->UninstallExtension(id, false);
+    }
   } else {
     LOG(ERROR) << "Trying to uninstall nonexistent extension " << id;
   }
 }
 
 ExtensionsService* ExtensionModelAssociator::GetExtensionsService() {
   CHECK(sync_service_);
   Profile* profile = sync_service_->profile();
   CHECK(profile);
   ExtensionsService* extensions_service = profile->GetExtensionsService();
   CHECK(extensions_service);
   return extensions_service;
 }
 
-bool ExtensionModelAssociator::GetExtensionDataFromClient(
-    const std::string& id, sync_pb::ExtensionSpecifics* client_data) {
-  ExtensionsService* extensions_service = GetExtensionsService();
-  Extension* extension = extensions_service->GetExtensionById(id, true);
-  if (!extension) {
-    return false;
-  }
-  GetExtensionSpecifics(*extension, extensions_service, client_data);
-  DcheckIsExtensionSpecificsValid(*client_data);
-  return true;
-}
-
 bool ExtensionModelAssociator::GetExtensionDataFromServer(
     const std::string& id, sync_api::WriteTransaction* trans,
     const sync_api::ReadNode& root,
     sync_pb::ExtensionSpecifics* server_data) {
   sync_api::ReadNode sync_node(trans);
   if (!sync_node.InitByClientTagLookup(syncable::EXTENSIONS, id)) {
     LOG(ERROR) << "Failed to fetch sync node for id " << id;
     return false;
   }
   const sync_pb::ExtensionSpecifics& read_server_data =
@@ skipping 48 matching lines @@
     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);
   ExtensionsService* extensions_service = GetExtensionsService();
   const std::string& id = specifics.id();
   Extension* extension = extensions_service->GetExtensionById(id, true);
   if (extension) {
+    if (!IsExtensionSyncable(*extension)) {
+      LOG(DFATAL) << "TryUpdateClient() called for non-syncable extension "
+                  << extension->id();
+      return;
+    }
     SetExtensionProperties(specifics, extensions_service, extension);
     {
       sync_pb::ExtensionSpecifics extension_specifics;
       GetExtensionSpecifics(*extension, extensions_service,
                             &extension_specifics);
       DCHECK(AreExtensionSpecificsUserPropertiesEqual(
           specifics, extension_specifics))
           << ExtensionSpecificsToString(specifics) << ", "
           << ExtensionSpecificsToString(extension_specifics);
     }
@@ skipping 18 matching lines @@
   // ExtensionsService in ProfileImpl::InitExtensions()).
   if (extension_updater) {
     extension_updater->CheckNow();
   } else {
     LOG(DFATAL) << "Extension updater unexpectedly NULL; "
                 << "auto-updates may be turned off";
   }
 }
 
 }  // namespace browser_sync