Pass Content-security-policy and header type from WebSharedWorkerProxy to WebSharedWorkerStub.

content/renderer/websharedworker_proxy.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/websharedworker_proxy.h"
 #include "content/common/child_thread.h"
 #include "content/common/view_messages.h"
 #include "content/common/webmessageportchannel_impl.h"
 #include "content/common/worker_messages.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURL.h"
@@ skipping 27 matching lines @@
     return;
 
   // So the messages from WorkerContext (like WorkerContextDestroyed) do not
   // come after nobody is listening. Since Worker and WorkerContext can
   // terminate independently, already sent messages may still be in the pipe.
   child_thread_->RemoveRoute(route_id_);
 
   route_id_ = MSG_ROUTING_NONE;
 }
 
-void WebSharedWorkerProxy::CreateWorkerContext(const GURL& script_url,
-                                        bool is_shared,
-                                        const string16& name,
-                                        const string16& user_agent,
-                                        const string16& source_code,
-                                        int pending_route_id,
-                                        int64 script_resource_appcache_id) {
+void WebSharedWorkerProxy::CreateWorkerContext(
+    const GURL& script_url,
+    bool is_shared,
+    const string16& name,
+    const string16& user_agent,
+    const string16& source_code,
+    const string16& content_security_policy,
+    WebKit::WebContentSecurityPolicyType policy_type,
+    int pending_route_id,
+    int64 script_resource_appcache_id) {
   DCHECK(route_id_ == MSG_ROUTING_NONE);
   ViewHostMsg_CreateWorker_Params params;
   params.url = script_url;
   params.name = name;
   params.document_id = document_id_;
   params.render_view_route_id = render_view_route_id_;
   params.route_id = pending_route_id;
   params.script_resource_appcache_id = script_resource_appcache_id;
   IPC::Message* create_message = new ViewHostMsg_CreateWorker(
       params, &route_id_);
   child_thread_->Send(create_message);
   if (route_id_ == MSG_ROUTING_NONE)
     return;
 
   child_thread_->AddRoute(route_id_, this);
 
   // We make sure that the start message is the first, since postMessage or
   // connect might have already been called.
   queued_messages_.insert(queued_messages_.begin(),
       new WorkerMsg_StartWorkerContext(
-          route_id_, script_url, user_agent, source_code));
+          route_id_, script_url, user_agent, source_code,
+          content_security_policy, policy_type));
 }
 
 bool WebSharedWorkerProxy::IsStarted() {
   // Worker is started if we have a route ID and there are no queued messages
   // (meaning we've sent the WorkerMsg_StartWorkerContext already).
   return (route_id_ != MSG_ROUTING_NONE && queued_messages_.empty());
 }
 
 bool WebSharedWorkerProxy::Send(IPC::Message* message) {
   // It's possible that messages will be sent before the worker is created, in
@@ skipping 26 matching lines @@
 bool WebSharedWorkerProxy::isStarted() {
   return IsStarted();
 }
 
 void WebSharedWorkerProxy::startWorkerContext(
     const WebKit::WebURL& script_url,
     const WebKit::WebString& name,
     const WebKit::WebString& user_agent,
     const WebKit::WebString& source_code,
     long long script_resource_appcache_id) {
+  CreateWorkerContext(
+      script_url, true, name, user_agent, source_code, string16(),
+      WebKit::WebContentSecurityPolicyTypeReportOnly, pending_route_id_,
+      script_resource_appcache_id);
+}
+
+void WebSharedWorkerProxy::startWorkerContext(
+    const WebKit::WebURL& script_url,
+    const WebKit::WebString& name,
+    const WebKit::WebString& user_agent,
+    const WebKit::WebString& source_code,
+    const WebKit::WebString& content_security_policy,
+    WebKit::WebContentSecurityPolicyType policy_type,
+    long long script_resource_appcache_id) {
   DCHECK(!isStarted());
-  CreateWorkerContext(script_url, true, name, user_agent, source_code,
-                      pending_route_id_, script_resource_appcache_id);
+  CreateWorkerContext(
+      script_url, true, name, user_agent, source_code, content_security_policy,
+      policy_type, pending_route_id_, script_resource_appcache_id);
 }
 
 void WebSharedWorkerProxy::terminateWorkerContext() {
   // This API should only be invoked from worker context.
   NOTREACHED();
 }
 
 void WebSharedWorkerProxy::clientDestroyed() {
   // This API should only be invoked from worker context.
   NOTREACHED();
@@ skipping 31 matching lines @@
   // The worker is created - now send off the CreateWorkerContext message and
   // any other queued messages
   SendQueuedMessages();
 
   // Inform any listener that the pending connect event has been sent
   // (this can result in this object being freed).
   if (connect_listener_) {
     connect_listener_->connected();
   }
 }