Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/shared_worker/shared_worker_service_impl.cc

 // Copyright 2014 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/browser/shared_worker/shared_worker_service_impl.h"
 
 #include <stddef.h>
+
 #include <algorithm>
 #include <iterator>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "content/browser/devtools/shared_worker_devtools_manager.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/shared_worker/shared_worker_host.h"
 #include "content/browser/shared_worker/shared_worker_instance.h"
 #include "content/browser/shared_worker/shared_worker_message_filter.h"
 #include "content/browser/shared_worker/worker_document_set.h"
 #include "content/common/view_messages.h"
 #include "content/common/worker_messages.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 96 matching lines @@
     SharedWorkerMessageFilter* const filter;
     const int route_id;
     const unsigned long long document_id;
     const int render_process_id;
     const int render_frame_route_id;
   };
 
   typedef ScopedVector<SharedWorkerPendingRequest> SharedWorkerPendingRequests;
 
   explicit SharedWorkerPendingInstance(
-      scoped_ptr<SharedWorkerInstance> instance)
+      std::unique_ptr<SharedWorkerInstance> instance)
       : instance_(std::move(instance)) {}
   ~SharedWorkerPendingInstance() {}
   SharedWorkerInstance* instance() { return instance_.get(); }
   SharedWorkerInstance* release_instance() { return instance_.release(); }
   SharedWorkerPendingRequests* requests() { return &requests_; }
   SharedWorkerMessageFilter* FindFilter(int process_id) {
     for (size_t i = 0; i < requests_.size(); ++i) {
       if (requests_[i]->render_process_id == process_id)
         return requests_[i]->filter;
     }
     return NULL;
   }
-  void AddRequest(scoped_ptr<SharedWorkerPendingRequest> request_info) {
+  void AddRequest(std::unique_ptr<SharedWorkerPendingRequest> request_info) {
     requests_.push_back(request_info.release());
   }
   void RemoveRequest(int process_id) {
     for (SharedWorkerPendingRequests::iterator request_itr = requests_.begin();
          request_itr != requests_.end();) {
       if ((*request_itr)->render_process_id == process_id)
         request_itr = requests_.erase(request_itr);
       else
         ++request_itr;
     }
   }
   void RegisterToSharedWorkerHost(SharedWorkerHost* host) {
     for (size_t i = 0; i < requests_.size(); ++i) {
       SharedWorkerPendingRequest* request = requests_[i];
       host->AddFilter(request->filter, request->route_id);
       host->worker_document_set()->Add(request->filter,
                                        request->document_id,
                                        request->render_process_id,
                                        request->render_frame_route_id);
     }
   }
   void SendWorkerCreatedMessages() {
     for (size_t i = 0; i < requests_.size(); ++i) {
       SharedWorkerPendingRequest* request = requests_[i];
       request->filter->Send(new ViewMsg_WorkerCreated(request->route_id));
     }
   }
 
  private:
-  scoped_ptr<SharedWorkerInstance> instance_;
+  std::unique_ptr<SharedWorkerInstance> instance_;
   SharedWorkerPendingRequests requests_;
   DISALLOW_COPY_AND_ASSIGN(SharedWorkerPendingInstance);
 };
 
 class SharedWorkerServiceImpl::SharedWorkerReserver
     : public base::RefCountedThreadSafe<SharedWorkerReserver> {
  public:
   SharedWorkerReserver(int pending_instance_id,
                        int worker_process_id,
                        int worker_route_id,
@@ skipping 97 matching lines @@
 
 void SharedWorkerServiceImpl::CreateWorker(
     const ViewHostMsg_CreateWorker_Params& params,
     int route_id,
     SharedWorkerMessageFilter* filter,
     ResourceContext* resource_context,
     const WorkerStoragePartitionId& partition_id,
     blink::WebWorkerCreationError* creation_error) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   *creation_error = blink::WebWorkerCreationErrorNone;
-  scoped_ptr<SharedWorkerInstance> instance(new SharedWorkerInstance(
+  std::unique_ptr<SharedWorkerInstance> instance(new SharedWorkerInstance(
       params.url, params.name, params.content_security_policy,
       params.security_policy_type, params.creation_address_space,
       resource_context, partition_id, params.creation_context_type));
-  scoped_ptr<SharedWorkerPendingInstance::SharedWorkerPendingRequest> request(
-      new SharedWorkerPendingInstance::SharedWorkerPendingRequest(
-          filter,
-          route_id,
-          params.document_id,
-          filter->render_process_id(),
+  std::unique_ptr<SharedWorkerPendingInstance::SharedWorkerPendingRequest>
+      request(new SharedWorkerPendingInstance::SharedWorkerPendingRequest(
+          filter, route_id, params.document_id, filter->render_process_id(),
           params.render_frame_route_id));
   if (SharedWorkerPendingInstance* pending = FindPendingInstance(*instance)) {
     if (params.url != pending->instance()->url()) {
       *creation_error = blink::WebWorkerCreationErrorURLMismatch;
       return;
     }
     if (params.creation_context_type !=
         pending->instance()->creation_context_type()) {
       *creation_error = blink::WebWorkerCreationErrorSecureContextMismatch;
     }
     pending->AddRequest(std::move(request));
     return;
   }
-  scoped_ptr<SharedWorkerPendingInstance> pending_instance(
+  std::unique_ptr<SharedWorkerPendingInstance> pending_instance(
       new SharedWorkerPendingInstance(std::move(instance)));
   pending_instance->AddRequest(std::move(request));
   ReserveRenderProcessToCreateWorker(std::move(pending_instance),
                                      creation_error);
 }
 
 void SharedWorkerServiceImpl::ForwardToWorker(
     const IPC::Message& message,
     SharedWorkerMessageFilter* filter) {
   for (WorkerHostMap::const_iterator iter = worker_hosts_.begin();
@@ skipping 20 matching lines @@
     SharedWorkerMessageFilter* filter) {
   ScopedWorkerDependencyChecker checker(this);
   if (SharedWorkerHost* host = FindSharedWorkerHost(filter, worker_route_id))
     host->WorkerContextClosed();
 }
 
 void SharedWorkerServiceImpl::WorkerContextDestroyed(
     int worker_route_id,
     SharedWorkerMessageFilter* filter) {
   ScopedWorkerDependencyChecker checker(this);
-  scoped_ptr<SharedWorkerHost> host =
-      worker_hosts_.take_and_erase(std::make_pair(filter->render_process_id(),
-                                                  worker_route_id));
+  std::unique_ptr<SharedWorkerHost> host = worker_hosts_.take_and_erase(
+      std::make_pair(filter->render_process_id(), worker_route_id));
   if (!host)
     return;
   host->WorkerContextDestroyed();
 }
 
 void SharedWorkerServiceImpl::WorkerReadyForInspection(
     int worker_route_id,
     SharedWorkerMessageFilter* filter) {
   if (SharedWorkerHost* host = FindSharedWorkerHost(filter, worker_route_id))
     host->WorkerReadyForInspection();
 }
 
 void SharedWorkerServiceImpl::WorkerScriptLoaded(
     int worker_route_id,
     SharedWorkerMessageFilter* filter) {
   if (SharedWorkerHost* host = FindSharedWorkerHost(filter, worker_route_id))
     host->WorkerScriptLoaded();
 }
 
 void SharedWorkerServiceImpl::WorkerScriptLoadFailed(
     int worker_route_id,
     SharedWorkerMessageFilter* filter) {
   ScopedWorkerDependencyChecker checker(this);
-  scoped_ptr<SharedWorkerHost> host =
-      worker_hosts_.take_and_erase(std::make_pair(filter->render_process_id(),
-                                                  worker_route_id));
+  std::unique_ptr<SharedWorkerHost> host = worker_hosts_.take_and_erase(
+      std::make_pair(filter->render_process_id(), worker_route_id));
   if (!host)
     return;
   host->WorkerScriptLoadFailed();
 }
 
 void SharedWorkerServiceImpl::WorkerConnected(
     int message_port_id,
     int worker_route_id,
     SharedWorkerMessageFilter* filter) {
   if (SharedWorkerHost* host = FindSharedWorkerHost(filter, worker_route_id))
     host->WorkerConnected(message_port_id);
 }
 
 void SharedWorkerServiceImpl::AllowFileSystem(
     int worker_route_id,
     const GURL& url,
     IPC::Message* reply_msg,
     SharedWorkerMessageFilter* filter) {
   if (SharedWorkerHost* host = FindSharedWorkerHost(filter, worker_route_id)) {
-    host->AllowFileSystem(url, make_scoped_ptr(reply_msg));
+    host->AllowFileSystem(url, base::WrapUnique(reply_msg));
   } else {
     filter->Send(reply_msg);
     return;
   }
 }
 
 void SharedWorkerServiceImpl::AllowIndexedDB(
     int worker_route_id,
     const GURL& url,
     const base::string16& name,
@@ skipping 10 matching lines @@
   ScopedWorkerDependencyChecker checker(this);
   std::vector<ProcessRouteIdPair> remove_list;
   for (WorkerHostMap::iterator iter = worker_hosts_.begin();
        iter != worker_hosts_.end();
        ++iter) {
     iter->second->FilterShutdown(filter);
     if (iter->first.first == filter->render_process_id())
       remove_list.push_back(iter->first);
   }
   for (size_t i = 0; i < remove_list.size(); ++i) {
-    scoped_ptr<SharedWorkerHost> host =
+    std::unique_ptr<SharedWorkerHost> host =
         worker_hosts_.take_and_erase(remove_list[i]);
   }
 
   std::vector<int> remove_pending_instance_list;
   for (PendingInstanceMap::iterator iter = pending_instances_.begin();
        iter != pending_instances_.end(); ++iter) {
     iter->second->RemoveRequest(filter->render_process_id());
     if (!iter->second->requests()->size())
       remove_pending_instance_list.push_back(iter->first);
   }
   for (size_t i = 0; i < remove_pending_instance_list.size(); ++i)
     pending_instances_.take_and_erase(remove_pending_instance_list[i]);
 }
 
 void SharedWorkerServiceImpl::NotifyWorkerDestroyed(int worker_process_id,
                                                     int worker_route_id) {
   FOR_EACH_OBSERVER(WorkerServiceObserver,
                     observers_,
                     WorkerDestroyed(worker_process_id, worker_route_id));
 }
 
 void SharedWorkerServiceImpl::ReserveRenderProcessToCreateWorker(
-    scoped_ptr<SharedWorkerPendingInstance> pending_instance,
+    std::unique_ptr<SharedWorkerPendingInstance> pending_instance,
     blink::WebWorkerCreationError* creation_error) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!FindPendingInstance(*pending_instance->instance()));
   if (creation_error)
     *creation_error = blink::WebWorkerCreationErrorNone;
   if (!pending_instance->requests()->size())
     return;
   int worker_process_id = -1;
   int worker_route_id = MSG_ROUTING_NONE;
   bool is_new_worker = true;
@@ skipping 53 matching lines @@
     int worker_process_id,
     int worker_route_id,
     bool is_new_worker,
     bool pause_on_start) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // To offset the TryIncrementWorkerRefCount called for the reservation,
   // calls DecrementWorkerRefCount after CheckWorkerDependency in
   // ScopeWorkerDependencyChecker's destructor.
   ScopedWorkerDependencyChecker checker(
       this, base::Bind(&DecrementWorkerRefCount, worker_process_id));
-  scoped_ptr<SharedWorkerPendingInstance> pending_instance =
+  std::unique_ptr<SharedWorkerPendingInstance> pending_instance =
       pending_instances_.take_and_erase(pending_instance_id);
   if (!pending_instance)
     return;
   if (!is_new_worker) {
     SharedWorkerHost* existing_host =
         worker_hosts_.get(std::make_pair(worker_process_id, worker_route_id));
     if (!existing_host) {
       // Retry reserving a renderer process if the existed Shared Worker was
       // destroyed on IO thread while reserving the renderer process on UI
       // thread.
       ReserveRenderProcessToCreateWorker(std::move(pending_instance), NULL);
       return;
     }
     pending_instance->RegisterToSharedWorkerHost(existing_host);
     pending_instance->SendWorkerCreatedMessages();
     return;
   }
   SharedWorkerMessageFilter* filter =
       pending_instance->FindFilter(worker_process_id);
   if (!filter) {
     pending_instance->RemoveRequest(worker_process_id);
     // Retry reserving a renderer process if the requested renderer process was
     // destroyed on IO thread while reserving the renderer process on UI thread.
     ReserveRenderProcessToCreateWorker(std::move(pending_instance), NULL);
     return;
   }
-  scoped_ptr<SharedWorkerHost> host(new SharedWorkerHost(
+  std::unique_ptr<SharedWorkerHost> host(new SharedWorkerHost(
       pending_instance->release_instance(), filter, worker_route_id));
   pending_instance->RegisterToSharedWorkerHost(host.get());
   const GURL url = host->instance()->url();
   const base::string16 name = host->instance()->name();
   host->Start(pause_on_start);
   worker_hosts_.set(std::make_pair(worker_process_id, worker_route_id),
                     std::move(host));
   FOR_EACH_OBSERVER(
       WorkerServiceObserver,
       observers_,
       WorkerCreated(url, name, worker_process_id, worker_route_id));
 }
 
 void SharedWorkerServiceImpl::RenderProcessReserveFailedCallback(
     int pending_instance_id,
     int worker_process_id,
     int worker_route_id,
     bool is_new_worker) {
   worker_hosts_.take_and_erase(
       std::make_pair(worker_process_id, worker_route_id));
-  scoped_ptr<SharedWorkerPendingInstance> pending_instance =
+  std::unique_ptr<SharedWorkerPendingInstance> pending_instance =
       pending_instances_.take_and_erase(pending_instance_id);
   if (!pending_instance)
     return;
   pending_instance->RemoveRequest(worker_process_id);
   // Retry reserving a renderer process.
   ReserveRenderProcessToCreateWorker(std::move(pending_instance), NULL);
 }
 
 SharedWorkerHost* SharedWorkerServiceImpl::FindSharedWorkerHost(
     SharedWorkerMessageFilter* filter,
@@ skipping 60 matching lines @@
     UpdateWorkerDependencyFunc new_func) {
   update_worker_dependency_ = new_func;
 }
 
 void SharedWorkerServiceImpl::ChangeTryIncrementWorkerRefCountFuncForTesting(
     bool (*new_func)(int)) {
   s_try_increment_worker_ref_count_ = new_func;
 }
 
 }  // namespace content