Upstream version 10.39.225.0

[platform/framework/web/crosswalk.git] / src / xwalk / extensions / browser / xwalk_extension_service.cc

diff --git a/src/xwalk/extensions/browser/xwalk_extension_service.cc b/src/xwalk/extensions/browser/xwalk_extension_service.cc
index 5e560a8..13df657 100644 (file)
--- a/src/xwalk/extensions/browser/xwalk_extension_service.cc
+++ b/src/xwalk/extensions/browser/xwalk_extension_service.cc
@@ -16,6 +16,7 @@
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "ipc/ipc_message_macros.h"
+#include "ipc/message_filter.h"
 #include "xwalk/extensions/browser/xwalk_extension_data.h"
 #include "xwalk/extensions/browser/xwalk_extension_process_host.h"
 #include "xwalk/extensions/common/xwalk_extension.h"
@@ -46,7 +47,7 @@ base::FilePath g_external_extensions_path_for_testing_;
 //
 // In the case of in process extensions, we will pass the task runner of the
 // extension thread.
-class ExtensionServerMessageFilter : public IPC::ChannelProxy::MessageFilter,
+class ExtensionServerMessageFilter : public IPC::MessageFilter,
                                      public IPC::Sender {
  public:
   ExtensionServerMessageFilter(
@@ -105,7 +106,7 @@ class ExtensionServerMessageFilter : public IPC::ChannelProxy::MessageFilter,
 
     if (ContainsKey(extension_thread_instances_ids_, id)) {
       server = extension_thread_server_;
-      task_runner = task_runner_;
+      task_runner = task_runner_.get();
     } else {
       server = ui_thread_server_;
       task_runner_ref =
@@ -115,7 +116,7 @@ class ExtensionServerMessageFilter : public IPC::ChannelProxy::MessageFilter,
 
     base::Closure closure = base::Bind(
         base::IgnoreResult(&XWalkExtensionServer::OnMessageReceived),
-        base::Unretained(server), message);
+        server->AsWeakPtr(), message);
 
     task_runner->PostTask(FROM_HERE, closure);
   }
@@ -128,7 +129,7 @@ class ExtensionServerMessageFilter : public IPC::ChannelProxy::MessageFilter,
     if (extension_thread_server_->ContainsExtension(name)) {
       extension_thread_instances_ids_.insert(instance_id);
       server = extension_thread_server_;
-      task_runner = task_runner_;
+      task_runner = task_runner_.get();
     } else {
       server = ui_thread_server_;
       task_runner_ref =
@@ -138,7 +139,7 @@ class ExtensionServerMessageFilter : public IPC::ChannelProxy::MessageFilter,
 
     base::Closure closure = base::Bind(
         base::IgnoreResult(&XWalkExtensionServer::OnCreateInstance),
-        base::Unretained(server), instance_id, name);
+        server->AsWeakPtr(), instance_id, name);
 
     task_runner->PostTask(FROM_HERE, closure);
   }
@@ -150,8 +151,8 @@ class ExtensionServerMessageFilter : public IPC::ChannelProxy::MessageFilter,
   }
 
   // IPC::ChannelProxy::MessageFilter implementation.
-  virtual void OnFilterAdded(IPC::Channel* channel) OVERRIDE {
-    sender_ = channel;
+  virtual void OnFilterAdded(IPC::Sender* sender) OVERRIDE {
+    sender_ = sender;
   }
 
   virtual void OnFilterRemoved() OVERRIDE {
@@ -200,8 +201,16 @@ class ExtensionServerMessageFilter : public IPC::ChannelProxy::MessageFilter,
   std::set<int64_t> extension_thread_instances_ids_;
 };
 
-XWalkExtensionService::XWalkExtensionService()
-    : extension_thread_("XWalkExtensionThread") {
+bool XWalkExtensionService::Delegate::RegisterPermissions(
+    int render_process_id,
+    const std::string& extension_name,
+    const std::string& perm_table) {
+  return false;
+}
+
+XWalkExtensionService::XWalkExtensionService(Delegate* delegate)
+    : extension_thread_("XWalkExtensionThread"),
+      delegate_(delegate) {
   if (!g_external_extensions_path_for_testing_.empty())
     external_extensions_path_ = g_external_extensions_path_for_testing_;
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
@@ -224,12 +233,11 @@ void XWalkExtensionService::RegisterExternalExtensionsForPath(
   external_extensions_path_ = path;
 }
 
-void XWalkExtensionService::OnRenderProcessHostCreated(
+void XWalkExtensionService::OnRenderProcessHostCreatedInternal(
     content::RenderProcessHost* host,
     XWalkExtensionVector* ui_thread_extensions,
-    XWalkExtensionVector* extension_thread_extensions) {
-  CHECK(host);
-
+    XWalkExtensionVector* extension_thread_extensions,
+    scoped_ptr<base::ValueMap> runtime_variables) {
   XWalkExtensionData* data = new XWalkExtensionData;
   data->set_render_process_host(host);
 
@@ -237,17 +245,36 @@ void XWalkExtensionService::OnRenderProcessHostCreated(
                                   extension_thread_extensions);
 
   CommandLine* cmd_line = CommandLine::ForCurrentProcess();
-  if (!cmd_line->HasSwitch(switches::kXWalkDisableExtensionProcess))
-    CreateExtensionProcessHost(host, data);
-  else if (!external_extensions_path_.empty()) {
+  if (!cmd_line->HasSwitch(switches::kXWalkDisableExtensionProcess)) {
+    CreateExtensionProcessHost(host, data, runtime_variables.Pass());
+  } else if (!external_extensions_path_.empty()) {
     RegisterExternalExtensionsInDirectory(
         data->in_process_ui_thread_server(),
-        external_extensions_path_);
+        external_extensions_path_, runtime_variables.Pass());
   }
 
   extension_data_map_[host->GetID()] = data;
 }
 
+void XWalkExtensionService::OnRenderProcessWillLaunch(
+    content::RenderProcessHost* host,
+    XWalkExtensionVector* ui_thread_extensions,
+    XWalkExtensionVector* extension_thread_extensions,
+    scoped_ptr<base::ValueMap> runtime_variables) {
+  CHECK(host);
+
+  if (!g_external_extensions_path_for_testing_.empty()) {
+    (*runtime_variables)["runtime_name"] =
+        new base::StringValue("xwalk");
+    OnRenderProcessHostCreatedInternal(host, ui_thread_extensions,
+        extension_thread_extensions, runtime_variables.Pass());
+    return;
+  }
+
+  OnRenderProcessHostCreatedInternal(host, ui_thread_extensions,
+      extension_thread_extensions, runtime_variables.Pass());
+}
+
 // static
 void
 XWalkExtensionService::SetCreateExtensionThreadExtensionsCallbackForTesting(
@@ -375,9 +402,11 @@ void XWalkExtensionService::CreateInProcessExtensionServers(
 }
 
 void XWalkExtensionService::CreateExtensionProcessHost(
-    content::RenderProcessHost* host, XWalkExtensionData* data) {
+    content::RenderProcessHost* host, XWalkExtensionData* data,
+    scoped_ptr<base::ValueMap> runtime_variables) {
   data->set_extension_process_host(make_scoped_ptr(
-      new XWalkExtensionProcessHost(host, external_extensions_path_, this)));
+      new XWalkExtensionProcessHost(host, external_extensions_path_, this,
+                                    runtime_variables.Pass())));
 }
 
 void XWalkExtensionService::OnExtensionProcessDied(
@@ -424,5 +453,31 @@ void XWalkExtensionService::OnRenderProcessDied(
   delete data;
 }
 
+void XWalkExtensionService::OnExtensionProcessCreated(
+      int render_process_id,
+      const IPC::ChannelHandle channel_handle) {
+  CHECK(delegate_);
+  delegate_->ExtensionProcessCreated(render_process_id, channel_handle);
+}
+
+void XWalkExtensionService::OnCheckAPIAccessControl(
+    int render_process_id,
+    const std::string& extension_name,
+    const std::string& api_name,
+    const PermissionCallback& callback) {
+  CHECK(delegate_);
+  delegate_->CheckAPIAccessControl(render_process_id, extension_name,
+                                   api_name, callback);
+}
+
+bool XWalkExtensionService::OnRegisterPermissions(
+    int render_process_id,
+    const std::string& extension_name,
+    const std::string& perm_table) {
+  CHECK(delegate_);
+  return delegate_->RegisterPermissions(render_process_id,
+                                        extension_name, perm_table);
+}
+
 }  // namespace extensions
 }  // namespace xwalk