Don't crash when trying to create an ExtensionSyncData from invalid SyncData.

chrome/browser/extensions/extension_sync_service.cc

 // Copyright 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/extensions/extension_sync_service.h"
 
 #include <iterator>
 
 #include "base/basictypes.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 21 matching lines @@
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_icon_set.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/image_util.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/manifest_handlers/icons_handler.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_error_factory.h"
 #include "ui/gfx/image/image_family.h"
 
+using extensions::AppSyncData;
 using extensions::Extension;
 using extensions::ExtensionPrefs;
 using extensions::ExtensionRegistry;
 using extensions::ExtensionSyncData;
 using extensions::FeatureSwitch;
 
 namespace {
 
 void OnWebApplicationInfoLoaded(
     WebApplicationInfo synced_info,
@@ skipping 201 matching lines @@
   return syncer::SyncDataList();
 }
 
 syncer::SyncError ExtensionSyncService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const syncer::SyncChangeList& change_list) {
   for (syncer::SyncChangeList::const_iterator i = change_list.begin();
       i != change_list.end();
       ++i) {
     syncer::ModelType type = i->sync_data().GetDataType();
-    if (type == syncer::EXTENSIONS)
-      extension_sync_bundle_.ProcessSyncChange(ExtensionSyncData(*i));
-    else if (type == syncer::APPS)
-      app_sync_bundle_.ProcessSyncChange(extensions::AppSyncData(*i));
+    if (type == syncer::EXTENSIONS) {
+      scoped_ptr<ExtensionSyncData> extension_data(
+          ExtensionSyncData::CreateFromSyncChange(*i));
+      if (extension_data.get())
+        extension_sync_bundle_.ProcessSyncChange(*extension_data);
+    } else if (type == syncer::APPS) {
+      scoped_ptr<AppSyncData> app_data(AppSyncData::CreateFromSyncChange(*i));
+      if (app_data.get())
+        app_sync_bundle_.ProcessSyncChange(*app_data);
+    }
   }
 
   extension_prefs_->app_sorting()->FixNTPOrdinalCollisions();
 
   return syncer::SyncError();
 }
 
 ExtensionSyncData ExtensionSyncService::GetExtensionSyncData(
     const Extension& extension) const {
   return ExtensionSyncData(
       extension,
       extension_service_->IsExtensionEnabled(extension.id()),
       extensions::util::IsIncognitoEnabled(extension.id(), profile_),
       extension_prefs_->HasDisableReason(extension.id(),
                                          Extension::DISABLE_REMOTE_INSTALL),
       GetAllowedOnAllUrlsOptionalBoolean(extension.id(), profile_));
 }
 
-extensions::AppSyncData ExtensionSyncService::GetAppSyncData(
+AppSyncData ExtensionSyncService::GetAppSyncData(
     const Extension& extension) const {
-  return extensions::AppSyncData(
-      extension,
-      extension_service_->IsExtensionEnabled(extension.id()),
+  return AppSyncData(
+      extension, extension_service_->IsExtensionEnabled(extension.id()),
       extensions::util::IsIncognitoEnabled(extension.id(), profile_),
       extension_prefs_->HasDisableReason(extension.id(),
                                          Extension::DISABLE_REMOTE_INSTALL),
       GetAllowedOnAllUrlsOptionalBoolean(extension.id(), profile_),
       extension_prefs_->app_sorting()->GetAppLaunchOrdinal(extension.id()),
       extension_prefs_->app_sorting()->GetPageOrdinal(extension.id()),
       extensions::GetLaunchTypePrefValue(extension_prefs_, extension.id()));
 }
 
 std::vector<ExtensionSyncData>
     ExtensionSyncService::GetExtensionSyncDataList() const {
   ExtensionRegistry* registry = ExtensionRegistry::Get(profile_);
   std::vector<ExtensionSyncData> extension_sync_list;
   extension_sync_bundle_.GetExtensionSyncDataListHelper(
       registry->enabled_extensions(), &extension_sync_list);
   extension_sync_bundle_.GetExtensionSyncDataListHelper(
       registry->disabled_extensions(), &extension_sync_list);
   extension_sync_bundle_.GetExtensionSyncDataListHelper(
       registry->terminated_extensions(), &extension_sync_list);
 
   std::vector<ExtensionSyncData> pending_extensions =
       extension_sync_bundle_.GetPendingData();
   extension_sync_list.insert(extension_sync_list.begin(),
                              pending_extensions.begin(),
                              pending_extensions.end());
 
   return extension_sync_list;
 }
 
-std::vector<extensions::AppSyncData> ExtensionSyncService::GetAppSyncDataList()
-    const {
+std::vector<AppSyncData> ExtensionSyncService::GetAppSyncDataList() const {
   ExtensionRegistry* registry = ExtensionRegistry::Get(profile_);
-  std::vector<extensions::AppSyncData> app_sync_list;
+  std::vector<AppSyncData> app_sync_list;
   app_sync_bundle_.GetAppSyncDataListHelper(
       registry->enabled_extensions(), &app_sync_list);
   app_sync_bundle_.GetAppSyncDataListHelper(
       registry->disabled_extensions(), &app_sync_list);
   app_sync_bundle_.GetAppSyncDataListHelper(
       registry->terminated_extensions(), &app_sync_list);
 
-  std::vector<extensions::AppSyncData> pending_apps =
-      app_sync_bundle_.GetPendingData();
+  std::vector<AppSyncData> pending_apps = app_sync_bundle_.GetPendingData();
   app_sync_list.insert(app_sync_list.begin(),
                        pending_apps.begin(),
                        pending_apps.end());
 
   return app_sync_list;
 }
 
 bool ExtensionSyncService::ProcessExtensionSyncData(
     const ExtensionSyncData& extension_sync_data) {
   if (!ProcessExtensionSyncDataHelper(extension_sync_data,
                                       syncer::EXTENSIONS)) {
     extension_sync_bundle_.AddPendingExtension(extension_sync_data.id(),
                                                extension_sync_data);
     extension_service_->CheckForUpdatesSoon();
     return false;
   }
 
   return true;
 }
 
 bool ExtensionSyncService::ProcessAppSyncData(
-    const extensions::AppSyncData& app_sync_data) {
+    const AppSyncData& app_sync_data) {
   const std::string& id = app_sync_data.id();
 
   if (app_sync_data.app_launch_ordinal().IsValid() &&
       app_sync_data.page_ordinal().IsValid()) {
     extension_prefs_->app_sorting()->SetAppLaunchOrdinal(
         id,
         app_sync_data.app_launch_ordinal());
     extension_prefs_->app_sorting()->SetPageOrdinal(
         id,
         app_sync_data.page_ordinal());
@@ skipping 13 matching lines @@
                                       syncer::APPS)) {
     app_sync_bundle_.AddPendingApp(id, app_sync_data);
     extension_service_->CheckForUpdatesSoon();
     return false;
   }
 
   return true;
 }
 
 void ExtensionSyncService::ProcessBookmarkAppSyncData(
-    const extensions::AppSyncData& app_sync_data) {
+    const AppSyncData& app_sync_data) {
   // Process bookmark app sync if necessary.
   GURL bookmark_app_url(app_sync_data.bookmark_app_url());
   if (!bookmark_app_url.is_valid() ||
       app_sync_data.extension_sync_data().uninstalled()) {
     return;
   }
 
   const extensions::Extension* extension =
       extension_service_->GetInstalledExtension(
           app_sync_data.extension_sync_data().id());
@@ skipping 180 matching lines @@
       app_sync_bundle_.SyncChangeIfNeeded(extension);
     else if (extension_service_->is_ready() && !flare_.is_null())
       flare_.Run(syncer::APPS);
   } else if (extensions::util::ShouldSyncExtension(&extension, profile_)) {
     if (extension_sync_bundle_.IsSyncing())
       extension_sync_bundle_.SyncChangeIfNeeded(extension);
     else if (extension_service_->is_ready() && !flare_.is_null())
       flare_.Run(syncer::EXTENSIONS);
   }
 }