src/xwalk/application/extension/application_widget_extension.cc

   1 // Copyright (c) 2014 Intel Corporation. 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 "xwalk/application/extension/application_widget_extension.h"
   6
   7 #include "base/bind.h"
   8 #include "base/path_service.h"
   9 #include "base/strings/string_util.h"
  10 #include "content/public/browser/browser_thread.h"
  11 #include "content/public/browser/web_contents.h"
  12 #include "ipc/ipc_message.h"
  13 #include "grit/xwalk_application_resources.h"
  14 #include "ui/base/resource/resource_bundle.h"
  15 #include "xwalk/application/browser/application.h"
  16 #include "xwalk/application/common/application_data.h"
  17 #include "xwalk/application/common/application_manifest_constants.h"
  18 #include "xwalk/application/common/manifest_handlers/widget_handler.h"
  19 #include "xwalk/application/extension/application_widget_storage.h"
  20 #include "xwalk/runtime/browser/runtime.h"
  21 #include "xwalk/runtime/browser/runtime_context.h"
  22 #include "xwalk/runtime/browser/xwalk_runner.h"
  23 #include "xwalk/runtime/common/xwalk_paths.h"
  24
  25 using content::BrowserThread;
  26
  27 namespace {
  28 const char kCommandKey[] = "cmd";
  29 const char kWidgetAttributeKey[] = "widgetKey";
  30 const char kPreferencesItemKey[] = "preferencesItemKey";
  31 const char kPreferencesItemValue[] = "preferencesItemValue";
  32 }
  33
  34 namespace xwalk {
  35 namespace application {
  36
  37 namespace widget_keys = xwalk::application_widget_keys;
  38
  39 ApplicationWidgetExtension::ApplicationWidgetExtension(
  40     Application* application)
  41   : application_(application) {
  42   set_name("widget");
  43   set_javascript_api(ResourceBundle::GetSharedInstance().GetRawDataResource(
  44       IDR_XWALK_APPLICATION_WIDGET_API).as_string());
  45 }
  46
  47 XWalkExtensionInstance* ApplicationWidgetExtension::CreateInstance() {
  48   return new AppWidgetExtensionInstance(application_);
  49 }
  50
  51 AppWidgetExtensionInstance::AppWidgetExtensionInstance(
  52     Application* application)
  53   : application_(application),
  54     handler_(this) {
  55   DCHECK(application_);
  56   base::ThreadRestrictions::SetIOAllowed(true);
  57
  58   base::FilePath path;
  59   xwalk::RegisterPathProvider();
  60   PathService::Get(xwalk::DIR_WGT_STORAGE_PATH, &path);
  61   widget_storage_.reset(new AppWidgetStorage(application_, path));
  62 }
  63
  64 AppWidgetExtensionInstance::~AppWidgetExtensionInstance() {}
  65
  66 void AppWidgetExtensionInstance::HandleMessage(scoped_ptr<base::Value> msg) {
  67   handler_.HandleMessage(msg.Pass());
  68 }
  69
  70 void AppWidgetExtensionInstance::HandleSyncMessage(
  71     scoped_ptr<base::Value> msg) {
  72   base::DictionaryValue* dict;
  73   std::string command;
  74   msg->GetAsDictionary(&dict);
  75
  76   if (!msg->GetAsDictionary(&dict) || !dict->GetString(kCommandKey, &command)) {
  77     LOG(ERROR) << "Fail to handle command sync message.";
  78     SendSyncReplyToJS(scoped_ptr<base::Value>(
  79         base::Value::CreateStringValue("")));
  80     return;
  81   }
  82
  83   scoped_ptr<base::Value> result(base::Value::CreateStringValue(""));
  84   if (command == "GetWidgetInfo") {
  85     result = GetWidgetInfo(msg.Pass());
  86   } else if (command == "SetPreferencesItem") {
  87     result = SetPreferencesItem(msg.Pass());
  88   } else if (command == "RemovePreferencesItem") {
  89     result = RemovePreferencesItem(msg.Pass());
  90   } else if (command == "ClearAllItems") {
  91     result = ClearAllItems(msg.Pass());
  92   } else if (command == "GetAllItems") {
  93     result = GetAllItems(msg.Pass());
  94   } else if (command == "KeyExists") {
  95     result = KeyExists(msg.Pass());
  96   } else {
  97     LOG(ERROR) << command << " ASSERT NOT REACHED.";
  98   }
  99
 100   SendSyncReplyToJS(result.Pass());
 101 }
 102
 103 scoped_ptr<base::StringValue> AppWidgetExtensionInstance::GetWidgetInfo(
 104     scoped_ptr<base::Value> msg) {
 105   scoped_ptr<base::StringValue> result(base::Value::CreateStringValue(""));
 106   std::string key;
 107   std::string value;
 108   base::DictionaryValue* dict;
 109
 110   if (!msg->GetAsDictionary(&dict) ||
 111       !dict->GetString(kWidgetAttributeKey, &key)) {
 112     LOG(ERROR) << "Fail to get widget attribute key.";
 113     return result.Pass();
 114   }
 115
 116   WidgetInfo* info =
 117       static_cast<WidgetInfo*>(
 118       application_->data()->GetManifestData(widget_keys::kWidgetKey));
 119   base::DictionaryValue* widget_info = info->GetWidgetInfo();
 120   widget_info->GetString(key, &value);
 121   result.reset(base::Value::CreateStringValue(value));
 122   return result.Pass();
 123 }
 124
 125 scoped_ptr<base::FundamentalValue>
 126 AppWidgetExtensionInstance::SetPreferencesItem(scoped_ptr<base::Value> msg) {
 127   scoped_ptr<base::FundamentalValue> result(
 128       base::Value::CreateBooleanValue(false));
 129   std::string key;
 130   std::string value;
 131   base::DictionaryValue* dict;
 132
 133   if (!msg->GetAsDictionary(&dict) ||
 134       !dict->GetString(kPreferencesItemKey, &key) ||
 135       !dict->GetString(kPreferencesItemValue, &value)) {
 136     LOG(ERROR) << "Fail to set preferences item.";
 137     return result.Pass();
 138   }
 139
 140   if (widget_storage_->AddEntry(key, value, false))
 141     result.reset(base::Value::CreateBooleanValue(true));
 142
 143   return result.Pass();
 144 }
 145
 146 scoped_ptr<base::FundamentalValue>
 147 AppWidgetExtensionInstance::RemovePreferencesItem(scoped_ptr<base::Value> msg) {
 148   scoped_ptr<base::FundamentalValue> result(
 149       base::Value::CreateBooleanValue(false));
 150   std::string key;
 151   base::DictionaryValue* dict;
 152
 153   if (!msg->GetAsDictionary(&dict) ||
 154       !dict->GetString(kPreferencesItemKey, &key)) {
 155     LOG(ERROR) << "Fail to remove preferences item.";
 156     return result.Pass();
 157   }
 158
 159   if (widget_storage_->RemoveEntry(key))
 160     result.reset(base::Value::CreateBooleanValue(true));
 161
 162   return result.Pass();
 163 }
 164
 165 scoped_ptr<base::FundamentalValue> AppWidgetExtensionInstance::ClearAllItems(
 166     scoped_ptr<base::Value> msg) {
 167   scoped_ptr<base::FundamentalValue> result(
 168       base::Value::CreateBooleanValue(false));
 169
 170   if (widget_storage_->Clear())
 171     result.reset(base::Value::CreateBooleanValue(true));
 172
 173   return result.Pass();
 174 }
 175
 176 scoped_ptr<base::DictionaryValue> AppWidgetExtensionInstance::GetAllItems(
 177     scoped_ptr<base::Value> msg) {
 178   scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
 179   widget_storage_->GetAllEntries(result.get());
 180
 181   return result.Pass();
 182 }
 183
 184 scoped_ptr<base::FundamentalValue> AppWidgetExtensionInstance::KeyExists(
 185     scoped_ptr<base::Value> msg) const {
 186   scoped_ptr<base::FundamentalValue> result(
 187       base::Value::CreateBooleanValue(false));
 188   std::string key;
 189   base::DictionaryValue* dict;
 190
 191   if (!msg->GetAsDictionary(&dict) ||
 192       !dict->GetString(kPreferencesItemKey, &key)) {
 193     LOG(ERROR) << "Fail to remove preferences item.";
 194     return result.Pass();
 195   }
 196
 197   if (widget_storage_->EntryExists(key))
 198     result.reset(base::Value::CreateBooleanValue(true));
 199
 200   return result.Pass();
 201 }
 202
 203 }  // namespace application
 204 }  // namespace xwalk