chrome/browser/extensions/api/storage/settings_sync_util.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/extensions/api/storage/settings_sync_util.h"
   6
   7 #include "base/json/json_writer.h"
   8 #include "base/values.h"
   9 #include "chrome/browser/extensions/api/storage/sync_value_store_cache.h"
  10 #include "content/public/browser/browser_thread.h"
  11 #include "extensions/browser/api/storage/storage_frontend.h"
  12 #include "sync/protocol/app_setting_specifics.pb.h"
  13 #include "sync/protocol/extension_setting_specifics.pb.h"
  14 #include "sync/protocol/sync.pb.h"
  15
  16 using content::BrowserThread;
  17
  18 namespace extensions {
  19
  20 namespace settings_sync_util {
  21
  22 namespace {
  23
  24 void PopulateExtensionSettingSpecifics(
  25     const std::string& extension_id,
  26     const std::string& key,
  27     const base::Value& value,
  28     sync_pb::ExtensionSettingSpecifics* specifics) {
  29   specifics->set_extension_id(extension_id);
  30   specifics->set_key(key);
  31   {
  32     std::string value_as_json;
  33     base::JSONWriter::Write(value, &value_as_json);
  34     specifics->set_value(value_as_json);
  35   }
  36 }
  37
  38 void PopulateAppSettingSpecifics(
  39     const std::string& extension_id,
  40     const std::string& key,
  41     const base::Value& value,
  42     sync_pb::AppSettingSpecifics* specifics) {
  43   PopulateExtensionSettingSpecifics(
  44       extension_id, key, value, specifics->mutable_extension_setting());
  45 }
  46
  47 }  // namespace
  48
  49 syncer::SyncData CreateData(
  50     const std::string& extension_id,
  51     const std::string& key,
  52     const base::Value& value,
  53     syncer::ModelType type) {
  54   sync_pb::EntitySpecifics specifics;
  55   switch (type) {
  56     case syncer::EXTENSION_SETTINGS:
  57       PopulateExtensionSettingSpecifics(
  58           extension_id,
  59           key,
  60           value,
  61           specifics.mutable_extension_setting());
  62       break;
  63
  64     case syncer::APP_SETTINGS:
  65       PopulateAppSettingSpecifics(
  66           extension_id,
  67           key,
  68           value,
  69           specifics.mutable_app_setting());
  70       break;
  71
  72     default:
  73       NOTREACHED();
  74   }
  75
  76   return syncer::SyncData::CreateLocalData(
  77       extension_id + "/" + key, key, specifics);
  78 }
  79
  80 syncer::SyncChange CreateAdd(
  81     const std::string& extension_id,
  82     const std::string& key,
  83     const base::Value& value,
  84     syncer::ModelType type) {
  85   return syncer::SyncChange(
  86       FROM_HERE,
  87       syncer::SyncChange::ACTION_ADD,
  88       CreateData(extension_id, key, value, type));
  89 }
  90
  91 syncer::SyncChange CreateUpdate(
  92     const std::string& extension_id,
  93     const std::string& key,
  94     const base::Value& value,
  95     syncer::ModelType type) {
  96   return syncer::SyncChange(
  97       FROM_HERE,
  98       syncer::SyncChange::ACTION_UPDATE,
  99       CreateData(extension_id, key, value, type));
 100 }
 101
 102 syncer::SyncChange CreateDelete(
 103     const std::string& extension_id,
 104     const std::string& key,
 105     syncer::ModelType type) {
 106   base::DictionaryValue no_value;
 107   return syncer::SyncChange(
 108       FROM_HERE,
 109       syncer::SyncChange::ACTION_DELETE,
 110       CreateData(extension_id, key, no_value, type));
 111 }
 112
 113 syncer::SyncableService* GetSyncableService(content::BrowserContext* context,
 114                                             syncer::ModelType type) {
 115   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 116   DCHECK(type == syncer::APP_SETTINGS || type == syncer::EXTENSION_SETTINGS);
 117   StorageFrontend* frontend = StorageFrontend::Get(context);
 118   SyncValueStoreCache* sync_cache = static_cast<SyncValueStoreCache*>(
 119       frontend->GetValueStoreCache(settings_namespace::SYNC));
 120   return sync_cache->GetSyncableService(type);
 121 }
 122
 123 }  // namespace settings_sync_util
 124
 125 }  // namespace extensions