SharedWorker: Document lifetime of SharedWorkerHost

content/browser/shared_worker/shared_worker_host.h

 // 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.
 
 #ifndef CONTENT_BROWSER_SHARED_WORKER_SHARED_WORKER_HOST_H_
 #define CONTENT_BROWSER_SHARED_WORKER_SHARED_WORKER_HOST_H_
 
 #include <list>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string16.h"
 #include "base/time/time.h"
-#include "content/browser/shared_worker/shared_worker_message_filter.h"
 #include "content/browser/shared_worker/worker_document_set.h"
 
 class GURL;
 
 namespace IPC {
 class Message;
 }
 
 namespace content {
+
 class SharedWorkerMessageFilter;
 class SharedWorkerInstance;
 
 // The SharedWorkerHost is the interface that represents the browser side of
-// the browser <-> worker communication channel.
+// the browser <-> worker communication channel. This is owned by
+// SharedWorkerServiceImpl and destructed when a worker context or worker's
+// message filter is closed.
 class SharedWorkerHost {
  public:
   SharedWorkerHost(SharedWorkerInstance* instance,
                    SharedWorkerMessageFilter* filter,
                    int worker_route_id);
   ~SharedWorkerHost();
 
   // Sends |message| to the SharedWorker.
   bool Send(IPC::Message* message);

[horo, 2017/01/06 04:50:05]

nit:
move to private.

[nhiroki, 2017/01/06 05:33:15]

Done.

 
   // Starts the SharedWorker in the renderer process which is associated with
   // |filter_|.
   void Start(bool pause_on_start);
 
   // Returns true iff the given message from a renderer process was forwarded to
   // the worker.
   bool FilterConnectionMessage(int route_id,
                                int sent_message_port_id,
                                SharedWorkerMessageFilter* incoming_filter);
@@ skipping 26 matching lines @@
 
   // Terminates the given worker, i.e. based on a UI action.
   void TerminateWorker();
 
   void AddFilter(SharedWorkerMessageFilter* filter, int route_id);
 
   SharedWorkerInstance* instance() { return instance_.get(); }
   WorkerDocumentSet* worker_document_set() const {
     return worker_document_set_.get();
   }
-  SharedWorkerMessageFilter* container_render_filter() const {
-    return container_render_filter_;
+  SharedWorkerMessageFilter* worker_render_filter() const {
+    return worker_render_filter_;
   }
   int process_id() const { return worker_process_id_; }
   int worker_route_id() const { return worker_route_id_; }
   bool IsAvailable() const;
 
  private:
   // Unique identifier for a worker client.
   class FilterInfo {
    public:
     FilterInfo(SharedWorkerMessageFilter* filter, int route_id)
@@ skipping 21 matching lines @@
                SharedWorkerMessageFilter* incoming_filter);
   void SetMessagePortID(SharedWorkerMessageFilter* filter,
                         int route_id,
                         int message_port_id);
   void AllowFileSystemResponse(std::unique_ptr<IPC::Message> reply_msg,
                                bool allowed);
 
   std::unique_ptr<SharedWorkerInstance> instance_;
   scoped_refptr<WorkerDocumentSet> worker_document_set_;
   FilterList filters_;
-  SharedWorkerMessageFilter* container_render_filter_;
+
+  // A message filter for a renderer process that hosts a worker. This is always
+  // valid because this host is destructed immediately after the filter is
+  // closed (see SharedWorkerServiceImpl::OnSharedWorkerMessageFilterClosing).
+  SharedWorkerMessageFilter* worker_render_filter_;
+
   const int worker_process_id_;
   const int worker_route_id_;
-  bool termination_message_sent_;
-  bool closed_;
+  bool termination_message_sent_ = false;
+  bool closed_ = false;
   const base::TimeTicks creation_time_;
 
   base::WeakPtrFactory<SharedWorkerHost> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SharedWorkerHost);
 };
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SHARED_WORKER_SHARED_WORKER_HOST_H_