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