src/xwalk/runtime/browser/xwalk_app_extension_bridge.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/runtime/browser/xwalk_app_extension_bridge.h"
   6
   7 #include <string>
   8
   9 #include "content/public/browser/browser_thread.h"
  10 #include "content/public/browser/notification_service.h"
  11 #include "xwalk/application/browser/application.h"
  12 #include "xwalk/application/browser/application_service.h"
  13 #include "xwalk/application/browser/application_system.h"
  14
  15 #if defined(OS_LINUX)
  16 #include "xwalk/application/browser/application_system_linux.h"
  17 #include "xwalk/application/browser/application_service_provider_linux.h"
  18 #include "xwalk/application/browser/linux/running_application_object.h"
  19 #endif
  20
  21 namespace xwalk {
  22
  23 using application::Application;
  24 using application::ApplicationService;
  25 using application::ApplicationSystem;
  26
  27 XWalkAppExtensionBridge::XWalkAppExtensionBridge()
  28     : app_system_(nullptr) {
  29 }
  30
  31 XWalkAppExtensionBridge::~XWalkAppExtensionBridge() {}
  32
  33 void XWalkAppExtensionBridge::CheckAPIAccessControl(
  34     int render_process_id,
  35     const std::string& extension_name,
  36     const std::string& api_name,
  37     const extensions::PermissionCallback& callback) {
  38   CHECK(app_system_);
  39   application::ApplicationService *service =
  40       app_system_->application_service();
  41
  42   application::Application *app =
  43       service->GetApplicationByRenderHostID(render_process_id);
  44   if (!app) {
  45     callback.Run(extensions::UNDEFINED_RUNTIME_PERM);
  46     return;
  47   }
  48
  49   service->CheckAPIAccessControl(app->id(), extension_name, api_name,
  50       *(reinterpret_cast<const xwalk::application::PermissionCallback*>
  51       (&callback)));
  52 }
  53
  54 bool XWalkAppExtensionBridge::RegisterPermissions(
  55     int render_process_id,
  56     const std::string& extension_name,
  57     const std::string& perm_table) {
  58   CHECK(app_system_);
  59   application::ApplicationService *service =
  60       app_system_->application_service();
  61   application::Application *app =
  62       service->GetApplicationByRenderHostID(render_process_id);
  63   if (!app)
  64     return false;
  65
  66   return service->RegisterPermissions(app->id(), extension_name, perm_table);
  67 }
  68
  69 void XWalkAppExtensionBridge::ExtensionProcessCreated(
  70     int render_process_id,
  71     const IPC::ChannelHandle& channel_handle) {
  72 #if defined(OS_LINUX)
  73   Application* app = GetApplication(render_process_id);
  74   CHECK(app);
  75
  76   application::ApplicationSystemLinux* app_system =
  77       static_cast<application::ApplicationSystemLinux*>(app_system_);
  78   application::RunningApplicationObject* running_app_object =
  79       app_system->service_provider()->GetRunningApplicationObject(app);
  80   CHECK(running_app_object);
  81   running_app_object->ExtensionProcessCreated(channel_handle);
  82 #endif
  83 }
  84
  85 void XWalkAppExtensionBridge::RenderChannelCreated(
  86     int render_process_id) {
  87   Application* app = GetApplication(render_process_id);
  88   if (!app)
  89     return;
  90   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
  91       base::Bind(&Application::RenderChannelCreated, app->GetWeakPtr()));
  92 }
  93
  94 Application* XWalkAppExtensionBridge::GetApplication(int render_process_id) {
  95   CHECK(app_system_);
  96   ApplicationService* service =
  97       app_system_->application_service();
  98   return service->GetApplicationByRenderHostID(render_process_id);
  99 }
 100
 101 }  // namespace xwalk