chrome/browser/themes/theme_syncable_service.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/themes/theme_syncable_service.h"
   6
   7 #include "base/strings/stringprintf.h"
   8 #include "chrome/browser/extensions/extension_service.h"
   9 #include "chrome/browser/profiles/profile.h"
  10 #include "chrome/browser/themes/theme_service.h"
  11 #include "chrome/common/extensions/manifest_url_handler.h"
  12 #include "chrome/common/extensions/sync_helper.h"
  13 #include "extensions/browser/extension_prefs.h"
  14 #include "extensions/browser/extension_system.h"
  15 #include "extensions/common/extension.h"
  16 #include "sync/protocol/sync.pb.h"
  17 #include "sync/protocol/theme_specifics.pb.h"
  18
  19 using std::string;
  20
  21 namespace {
  22
  23 bool IsTheme(const extensions::Extension* extension) {
  24   return extension->is_theme();
  25 }
  26
  27 // TODO(akalin): Remove this.
  28 bool IsSystemThemeDistinctFromDefaultTheme() {
  29 #if defined(TOOLKIT_GTK)
  30   return true;
  31 #else
  32   return false;
  33 #endif
  34 }
  35
  36 }  // namespace
  37
  38 const char ThemeSyncableService::kCurrentThemeClientTag[] = "current_theme";
  39 const char ThemeSyncableService::kCurrentThemeNodeTitle[] = "Current Theme";
  40
  41 ThemeSyncableService::ThemeSyncableService(Profile* profile,
  42                                            ThemeService* theme_service)
  43     : profile_(profile),
  44       theme_service_(theme_service),
  45       use_system_theme_by_default_(false) {
  46   DCHECK(profile_);
  47   DCHECK(theme_service_);
  48 }
  49
  50 ThemeSyncableService::~ThemeSyncableService() {
  51 }
  52
  53 void ThemeSyncableService::OnThemeChange() {
  54   if (sync_processor_.get()) {
  55     sync_pb::ThemeSpecifics current_specifics;
  56     if (!GetThemeSpecificsFromCurrentTheme(&current_specifics))
  57       return;  // Current theme is unsyncable.
  58     ProcessNewTheme(syncer::SyncChange::ACTION_UPDATE, current_specifics);
  59     use_system_theme_by_default_ =
  60         current_specifics.use_system_theme_by_default();
  61   }
  62 }
  63
  64 syncer::SyncMergeResult ThemeSyncableService::MergeDataAndStartSyncing(
  65     syncer::ModelType type,
  66     const syncer::SyncDataList& initial_sync_data,
  67     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
  68     scoped_ptr<syncer::SyncErrorFactory> error_handler) {
  69   DCHECK(thread_checker_.CalledOnValidThread());
  70   DCHECK(!sync_processor_.get());
  71   DCHECK(sync_processor.get());
  72   DCHECK(error_handler.get());
  73
  74   syncer::SyncMergeResult merge_result(type);
  75   sync_processor_ = sync_processor.Pass();
  76   sync_error_handler_ = error_handler.Pass();
  77
  78   if (initial_sync_data.size() > 1) {
  79     sync_error_handler_->CreateAndUploadError(
  80         FROM_HERE,
  81         base::StringPrintf("Received %d theme specifics.",
  82                            static_cast<int>(initial_sync_data.size())));
  83   }
  84
  85   sync_pb::ThemeSpecifics current_specifics;
  86   if (!GetThemeSpecificsFromCurrentTheme(&current_specifics)) {
  87     // Current theme is unsyncable - don't overwrite from sync data, and don't
  88     // save the unsyncable theme to sync data.
  89     return merge_result;
  90   }
  91
  92   // Find the last SyncData that has theme data and set the current theme from
  93   // it.
  94   for (syncer::SyncDataList::const_reverse_iterator sync_data =
  95       initial_sync_data.rbegin(); sync_data != initial_sync_data.rend();
  96       ++sync_data) {
  97     if (sync_data->GetSpecifics().has_theme()) {
  98       MaybeSetTheme(current_specifics, *sync_data);
  99       return merge_result;
 100     }
 101   }
 102
 103   // No theme specifics are found. Create one according to current theme.
 104   merge_result.set_error(ProcessNewTheme(
 105       syncer::SyncChange::ACTION_ADD, current_specifics));
 106   return merge_result;
 107 }
 108
 109 void ThemeSyncableService::StopSyncing(syncer::ModelType type) {
 110   DCHECK(thread_checker_.CalledOnValidThread());
 111   DCHECK_EQ(type, syncer::THEMES);
 112
 113   sync_processor_.reset();
 114   sync_error_handler_.reset();
 115 }
 116
 117 syncer::SyncDataList ThemeSyncableService::GetAllSyncData(
 118     syncer::ModelType type) const {
 119   DCHECK(thread_checker_.CalledOnValidThread());
 120   DCHECK_EQ(type, syncer::THEMES);
 121
 122   syncer::SyncDataList list;
 123   sync_pb::EntitySpecifics entity_specifics;
 124   if (GetThemeSpecificsFromCurrentTheme(entity_specifics.mutable_theme())) {
 125     list.push_back(syncer::SyncData::CreateLocalData(kCurrentThemeClientTag,
 126                                                      kCurrentThemeNodeTitle,
 127                                                      entity_specifics));
 128   }
 129   return list;
 130 }
 131
 132 syncer::SyncError ThemeSyncableService::ProcessSyncChanges(
 133     const tracked_objects::Location& from_here,
 134     const syncer::SyncChangeList& change_list) {
 135   DCHECK(thread_checker_.CalledOnValidThread());
 136
 137   if (!sync_processor_.get()) {
 138     return syncer::SyncError(FROM_HERE,
 139                              syncer::SyncError::DATATYPE_ERROR,
 140                              "Theme syncable service is not started.",
 141                              syncer::THEMES);
 142   }
 143
 144   // TODO(akalin): Normally, we should only have a single change and
 145   // it should be an update.  However, the syncapi may occasionally
 146   // generates multiple changes.  When we fix syncapi to not do that,
 147   // we can remove the extra logic below.  See:
 148   // http://code.google.com/p/chromium/issues/detail?id=41696 .
 149   if (change_list.size() != 1) {
 150     string err_msg = base::StringPrintf("Received %d theme changes: ",
 151                                         static_cast<int>(change_list.size()));
 152     for (size_t i = 0; i < change_list.size(); ++i) {
 153       base::StringAppendF(&err_msg, "[%s] ", change_list[i].ToString().c_str());
 154     }
 155     sync_error_handler_->CreateAndUploadError(FROM_HERE, err_msg);
 156   } else if (change_list.begin()->change_type() !=
 157           syncer::SyncChange::ACTION_ADD
 158       && change_list.begin()->change_type() !=
 159           syncer::SyncChange::ACTION_UPDATE) {
 160     sync_error_handler_->CreateAndUploadError(
 161         FROM_HERE,
 162         "Invalid theme change: " + change_list.begin()->ToString());
 163   }
 164
 165   sync_pb::ThemeSpecifics current_specifics;
 166   if (!GetThemeSpecificsFromCurrentTheme(&current_specifics)) {
 167     // Current theme is unsyncable, so don't overwrite it.
 168     return syncer::SyncError();
 169   }
 170
 171   // Set current theme from the theme specifics of the last change of type
 172   // |ACTION_ADD| or |ACTION_UPDATE|.
 173   for (syncer::SyncChangeList::const_reverse_iterator theme_change =
 174       change_list.rbegin(); theme_change != change_list.rend();
 175       ++theme_change) {
 176     if (theme_change->sync_data().GetSpecifics().has_theme() &&
 177         (theme_change->change_type() == syncer::SyncChange::ACTION_ADD ||
 178             theme_change->change_type() == syncer::SyncChange::ACTION_UPDATE)) {
 179       MaybeSetTheme(current_specifics, theme_change->sync_data());
 180       return syncer::SyncError();
 181     }
 182   }
 183
 184   return syncer::SyncError(FROM_HERE,
 185                            syncer::SyncError::DATATYPE_ERROR,
 186                            "Didn't find valid theme specifics",
 187                            syncer::THEMES);
 188 }
 189
 190 void ThemeSyncableService::MaybeSetTheme(
 191     const sync_pb::ThemeSpecifics& current_specs,
 192     const syncer::SyncData& sync_data) {
 193   const sync_pb::ThemeSpecifics& sync_theme = sync_data.GetSpecifics().theme();
 194   use_system_theme_by_default_ = sync_theme.use_system_theme_by_default();
 195   DVLOG(1) << "Set current theme from specifics: " << sync_data.ToString();
 196   if (!AreThemeSpecificsEqual(current_specs, sync_theme,
 197                               IsSystemThemeDistinctFromDefaultTheme())) {
 198     SetCurrentThemeFromThemeSpecifics(sync_theme);
 199   } else {
 200     DVLOG(1) << "Skip setting theme because specs are equal";
 201   }
 202 }
 203
 204 void ThemeSyncableService::SetCurrentThemeFromThemeSpecifics(
 205     const sync_pb::ThemeSpecifics& theme_specifics) {
 206   if (theme_specifics.use_custom_theme()) {
 207     // TODO(akalin): Figure out what to do about third-party themes
 208     // (i.e., those not on either Google gallery).
 209     string id(theme_specifics.custom_theme_id());
 210     GURL update_url(theme_specifics.custom_theme_update_url());
 211     DVLOG(1) << "Applying theme " << id << " with update_url " << update_url;
 212     ExtensionService* extensions_service =
 213         extensions::ExtensionSystem::Get(profile_)->extension_service();
 214     CHECK(extensions_service);
 215     const extensions::Extension* extension =
 216         extensions_service->GetExtensionById(id, true);
 217     if (extension) {
 218       if (!extension->is_theme()) {
 219         DVLOG(1) << "Extension " << id << " is not a theme; aborting";
 220         return;
 221       }
 222       int disabled_reasons =
 223           extensions::ExtensionPrefs::Get(profile_)->GetDisableReasons(id);
 224       if (!extensions_service->IsExtensionEnabled(id) &&
 225           disabled_reasons != extensions::Extension::DISABLE_USER_ACTION) {
 226         DVLOG(1) << "Theme " << id << " is disabled with reason "
 227                  << disabled_reasons << "; aborting";
 228         return;
 229       }
 230       // An enabled theme extension with the given id was found, so
 231       // just set the current theme to it.
 232       theme_service_->SetTheme(extension);
 233     } else {
 234       // No extension with this id exists -- we must install it; we do
 235       // so by adding it as a pending extension and then triggering an
 236       // auto-update cycle.
 237       const bool kInstallSilently = true;
 238       const bool kRemoteInstall = false;
 239       if (!extensions_service->pending_extension_manager()->AddFromSync(
 240               id, update_url, &IsTheme, kInstallSilently, kRemoteInstall)) {
 241         LOG(WARNING) << "Could not add pending extension for " << id;
 242         return;
 243       }
 244       extensions_service->CheckForUpdatesSoon();
 245     }
 246   } else if (theme_specifics.use_system_theme_by_default()) {
 247     DVLOG(1) << "Switch to use system theme";
 248     theme_service_->UseSystemTheme();
 249   } else {
 250     DVLOG(1) << "Switch to use default theme";
 251     theme_service_->UseDefaultTheme();
 252   }
 253 }
 254
 255 bool ThemeSyncableService::GetThemeSpecificsFromCurrentTheme(
 256     sync_pb::ThemeSpecifics* theme_specifics) const {
 257   const extensions::Extension* current_theme =
 258       theme_service_->UsingDefaultTheme() ?
 259           NULL :
 260           extensions::ExtensionSystem::Get(profile_)->extension_service()->
 261               GetExtensionById(theme_service_->GetThemeID(), false);
 262   if (current_theme && !extensions::sync_helper::IsSyncable(current_theme)) {
 263     DVLOG(1) << "Ignoring extension from external source: " <<
 264         current_theme->location();
 265     return false;
 266   }
 267   bool use_custom_theme = (current_theme != NULL);
 268   theme_specifics->set_use_custom_theme(use_custom_theme);
 269   if (IsSystemThemeDistinctFromDefaultTheme()) {
 270     // On platform where system theme is different from default theme, set
 271     // use_system_theme_by_default to true if system theme is used, false
 272     // if default system theme is used. Otherwise restore it to value in sync.
 273     if (theme_service_->UsingSystemTheme()) {
 274       theme_specifics->set_use_system_theme_by_default(true);
 275     } else if (theme_service_->UsingDefaultTheme()) {
 276       theme_specifics->set_use_system_theme_by_default(false);
 277     } else {
 278       theme_specifics->set_use_system_theme_by_default(
 279           use_system_theme_by_default_);
 280     }
 281   } else {
 282     // Restore use_system_theme_by_default when platform doesn't distinguish
 283     // between default theme and system theme.
 284     theme_specifics->set_use_system_theme_by_default(
 285         use_system_theme_by_default_);
 286   }
 287
 288   if (use_custom_theme) {
 289     DCHECK(current_theme);
 290     DCHECK(current_theme->is_theme());
 291     theme_specifics->set_custom_theme_name(current_theme->name());
 292     theme_specifics->set_custom_theme_id(current_theme->id());
 293     theme_specifics->set_custom_theme_update_url(
 294         extensions::ManifestURL::GetUpdateURL(current_theme).spec());
 295   } else {
 296     DCHECK(!current_theme);
 297     theme_specifics->clear_custom_theme_name();
 298     theme_specifics->clear_custom_theme_id();
 299     theme_specifics->clear_custom_theme_update_url();
 300   }
 301   return true;
 302 }
 303
 304 /* static */
 305 bool ThemeSyncableService::AreThemeSpecificsEqual(
 306     const sync_pb::ThemeSpecifics& a,
 307     const sync_pb::ThemeSpecifics& b,
 308     bool is_system_theme_distinct_from_default_theme) {
 309   if (a.use_custom_theme() != b.use_custom_theme()) {
 310     return false;
 311   }
 312
 313   if (a.use_custom_theme()) {
 314     // We're using a custom theme, so simply compare IDs since those
 315     // are guaranteed unique.
 316     return a.custom_theme_id() == b.custom_theme_id();
 317   } else if (is_system_theme_distinct_from_default_theme) {
 318     // We're not using a custom theme, but we care about system
 319     // vs. default.
 320     return a.use_system_theme_by_default() == b.use_system_theme_by_default();
 321   } else {
 322     // We're not using a custom theme, and we don't care about system
 323     // vs. default.
 324     return true;
 325   }
 326 }
 327
 328 syncer::SyncError ThemeSyncableService::ProcessNewTheme(
 329     syncer::SyncChange::SyncChangeType change_type,
 330     const sync_pb::ThemeSpecifics& theme_specifics) {
 331   syncer::SyncChangeList changes;
 332   sync_pb::EntitySpecifics entity_specifics;
 333   entity_specifics.mutable_theme()->CopyFrom(theme_specifics);
 334
 335   changes.push_back(
 336       syncer::SyncChange(FROM_HERE, change_type,
 337                          syncer::SyncData::CreateLocalData(
 338                              kCurrentThemeClientTag, kCurrentThemeNodeTitle,
 339                              entity_specifics)));
 340
 341   DVLOG(1) << "Update theme specifics from current theme: "
 342       << changes.back().ToString();
 343
 344   return sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 345 }