Changed shared worker code so incognito windows do not have access to non-incognito shared workers.

chrome/browser/worker_host/worker_service.cc

 // Copyright (c) 2009 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 "chrome/browser/worker_host/worker_service.h"
 
 #include "base/command_line.h"
 #include "base/singleton.h"
 #include "base/sys_info.h"
 #include "base/thread.h"
@@ skipping 29 matching lines @@
 
 void WorkerService::Initialize(ResourceDispatcherHost* rdh) {
   resource_dispatcher_host_ = rdh;
 }
 
 WorkerService::~WorkerService() {
 }
 
 bool WorkerService::CreateWorker(const GURL &url,
                                  bool is_shared,
+                                 bool off_the_record,
                                  const string16& name,
                                  int renderer_id,
                                  int render_view_route_id,
                                  IPC::Message::Sender* sender,
                                  int sender_route_id) {
   // Generate a unique route id for the browser-worker communication that's
   // unique among all worker processes.  That way when the worker process sends
   // a wrapped IPC message through us, we know which WorkerProcessHost to give
   // it to.
   WorkerProcessHost::WorkerInstance instance(url,
                                              is_shared,
+                                             off_the_record,
                                              name,
                                              renderer_id,
                                              render_view_route_id,
                                              next_worker_route_id());
   instance.AddSender(sender, sender_route_id);
 
   WorkerProcessHost* worker = NULL;
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kWebWorkerProcessPerCore)) {
     worker = GetProcessToFillUpCores();
   } else if (CommandLine::ForCurrentProcess()->HasSwitch(
                  switches::kWebWorkerShareProcesses)) {
     worker = GetProcessForDomain(url);
   } else {  // One process per worker.
     if (!CanCreateWorkerProcess(instance)) {
       queued_workers_.push_back(instance);
       return true;
     }
   }
 
   // Check to see if this shared worker is already running (two pages may have
   // tried to start up the worker simultaneously).
   if (is_shared) {
     // See if a worker with this name already exists.
     WorkerProcessHost::WorkerInstance* existing_instance =
-        FindSharedWorkerInstance(url, name);
+        FindSharedWorkerInstance(url, name, off_the_record);
     // If this worker is already running, no need to create a new copy. Just
     // inform the caller that the worker has been created.
     if (existing_instance) {
       existing_instance->AddSender(sender, sender_route_id);
       sender->Send(new ViewMsg_WorkerCreated(sender_route_id));
       return true;
     }
 
     // Look to see if there's a pending instance.
-    WorkerProcessHost::WorkerInstance* pending = FindPendingInstance(url, name);
+    WorkerProcessHost::WorkerInstance* pending = FindPendingInstance(
+        url, name, off_the_record);
     // If there's no instance *and* no pending instance, then it means the
     // worker started up and exited already. Log a warning because this should
     // be a very rare occurrence and is probably a bug, but it *can* happen so
     // handle it gracefully.
     if (!pending) {
       DLOG(WARNING) << "Pending worker already exited";
       return false;
     }
 
     // Assign the accumulated document set and sender list for this pending
     // worker to the new instance.
     DCHECK(!pending->IsDocumentSetEmpty());
     instance.CopyDocumentSet(*pending);
-    RemovePendingInstance(url, name);
+    RemovePendingInstance(url, name, off_the_record);
   }
 
   if (!worker) {
     worker = new WorkerProcessHost(resource_dispatcher_host_);
     if (!worker->Init()) {
       delete worker;
       return false;
     }
   }
 
   worker->CreateWorker(instance);
   return true;
 }
 
 bool WorkerService::LookupSharedWorker(const GURL &url,
                                        const string16& name,
+                                       bool off_the_record,
                                        unsigned long long document_id,
                                        IPC::Message::Sender* sender,
                                        int sender_route_id,
                                        bool* url_mismatch) {
   bool found_instance = true;
   WorkerProcessHost::WorkerInstance* instance =
-      FindSharedWorkerInstance(url, name);
+      FindSharedWorkerInstance(url, name, off_the_record);
 
   if (!instance) {
     // If no worker instance currently exists, we need to create a pending
     // instance - this is to make sure that any subsequent lookups passing a
     // mismatched URL get the appropriate url_mismatch error at lookup time.
     // Having named shared workers was a Really Bad Idea due to details like
     // this.
-    instance = CreatePendingInstance(url, name);
+    instance = CreatePendingInstance(url, name, off_the_record);
     found_instance = false;
   }
 
   // Make sure the passed-in instance matches the URL - if not, return an
   // error.
   if (url != instance->url()) {
     *url_mismatch = true;
     return false;
   } else {
     *url_mismatch = false;
@@ skipping 239 matching lines @@
 
     WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
     WorkerProcessHost::Instances::const_iterator instance =
         worker->instances().begin();
     return instance == worker->instances().end() ? NULL : &*instance;
   }
   return NULL;
 }
 
 WorkerProcessHost::WorkerInstance*
-WorkerService::FindSharedWorkerInstance(const GURL& url, const string16& name) {
+WorkerService::FindSharedWorkerInstance(const GURL& url, const string16& name,
+                                        bool off_the_record) {
   for (ChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
        !iter.Done(); ++iter) {
     WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
     for (WorkerProcessHost::Instances::iterator instance_iter =
              worker->mutable_instances().begin();
          instance_iter != worker->mutable_instances().end();
          ++instance_iter) {
-      if (instance_iter->Matches(url, name))
+      if (instance_iter->Matches(url, name, off_the_record))
         return &(*instance_iter);
     }
   }
   return NULL;
 }
 
 WorkerProcessHost::WorkerInstance*
-WorkerService::FindPendingInstance(const GURL& url, const string16& name) {
+WorkerService::FindPendingInstance(const GURL& url, const string16& name,
+                                   bool off_the_record) {
   // Walk the pending instances looking for a matching pending worker.
   for (WorkerProcessHost::Instances::iterator iter =
            pending_shared_workers_.begin();
        iter != pending_shared_workers_.end();
        ++iter) {
-    if (iter->Matches(url, name)) {
+    if (iter->Matches(url, name, off_the_record)) {
       return &(*iter);
     }
   }
   return NULL;
 }
 
 
 void WorkerService::RemovePendingInstance(const GURL& url,
-                                          const string16& name) {
+                                          const string16& name,
+                                          bool off_the_record) {
   // Walk the pending instances looking for a matching pending worker.
   for (WorkerProcessHost::Instances::iterator iter =
            pending_shared_workers_.begin();
        iter != pending_shared_workers_.end();
        ++iter) {
-    if (iter->Matches(url, name)) {
+    if (iter->Matches(url, name, off_the_record)) {
       pending_shared_workers_.erase(iter);
       break;
     }
   }
 }
 
 WorkerProcessHost::WorkerInstance*
 WorkerService::CreatePendingInstance(const GURL& url,
-                                     const string16& name) {
+                                     const string16& name,
+                                     bool off_the_record) {
   // Look for an existing pending worker.
   WorkerProcessHost::WorkerInstance* instance =
-      FindPendingInstance(url, name);
+      FindPendingInstance(url, name, off_the_record);
   if (instance)
     return instance;
 
   // No existing pending worker - create a new one.
   WorkerProcessHost::WorkerInstance pending(
-      url, true, name, 0, MSG_ROUTING_NONE, MSG_ROUTING_NONE);
+      url, true, off_the_record, name, 0, MSG_ROUTING_NONE, MSG_ROUTING_NONE);
   pending_shared_workers_.push_back(pending);
   return &pending_shared_workers_.back();
 }