Make LoadMonitoringExtensionHostQueue remove itself as an ExtensionHost observer at the correct tim…

extensions/browser/load_monitoring_extension_host_queue.h

 // Copyright 2015 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 EXTENSIONS_BROWSER_LOAD_MONITORING_EXTENSION_HOST_QUEUE_H_
 #define EXTENSIONS_BROWSER_LOAD_MONITORING_EXTENSION_HOST_QUEUE_H_
 
 #include <set>
 
 #include "base/callback.h"
@@ skipping 11 matching lines @@
 // ExtensionHosts are being loaded for some period of time.
 class LoadMonitoringExtensionHostQueue
     : public ExtensionHostQueue,
       public DeferredStartRenderHostObserver {
  public:
   // Construction for testing.
   // Allows overriding the default timeout and triggering a callback when
   // monitoring has finished (timeout has elapsed and UMA is logged).
   using FinishedCallback = base::Callback<void(size_t,  // num_queued
                                                size_t,  // max_loaded
-                                               size_t,  // max_in_queue
+                                               size_t,  // max_awaiting_loading
                                                size_t   // max_active_loading
                                                )>;
   LoadMonitoringExtensionHostQueue(scoped_ptr<ExtensionHostQueue> delegate,
                                    base::TimeDelta monitor_time,
                                    const FinishedCallback& finished_callback);
 
   // Production code should use this constructor.
   //
   // Monitoring will not start until the first Add()ed
   // DeferredStartRenderHost starts loading, or StartMonitoring() is called.
   explicit LoadMonitoringExtensionHostQueue(
       scoped_ptr<ExtensionHostQueue> delegate);
 
   ~LoadMonitoringExtensionHostQueue() override;
 
   // Starts monitoring.
   //
   // This can be called multiple times, but it has no effect if monitoring has
   // already started (or finished). Monitoring cannot be restarted.
   //
   // Note that monitoring will automatically start when Add() is called, so it
   // may not be necessary to call this at all.
   void StartMonitoring();
 
   // ExtensionHostQueue:
   void Add(DeferredStartRenderHost* host) override;
   void Remove(DeferredStartRenderHost* host) override;
 
   // DeferredStartRenderHostObserver, public to be triggered by tests:
-  void OnDeferredStartRenderHostDidStartLoading(
+  void OnDeferredStartRenderHostDidStartFirstLoad(
       const DeferredStartRenderHost* host) override;
-  void OnDeferredStartRenderHostDidStopLoading(
+  void OnDeferredStartRenderHostDidStopFirstLoad(
       const DeferredStartRenderHost* host) override;
   void OnDeferredStartRenderHostDestroyed(
       const DeferredStartRenderHost* host) override;
 
  private:
   // Starts/finishes monitoring |host|, though either will have no effect if
   // monitoring has already finished.
   void StartMonitoringHost(const DeferredStartRenderHost* host);
   void FinishMonitoringHost(const DeferredStartRenderHost* host);
 
-  // Removes |host| from the internal |in_queue_| tracking.
-  void RemoveFromQueue(const DeferredStartRenderHost* host);
-
   // Called when monitoring should finish. Metrics are recorded, and from this
   // point on no monitoring will take place.
   void FinishMonitoring();
 
   // Delegate actually loading DeferredStartRenderHosts to another queue.
   scoped_ptr<ExtensionHostQueue> delegate_;
 
   // The amount of time to monitor for. By default this is 1 minute, but it can
   // be overriden by tests.
   base::TimeDelta monitor_time_;
 
   // A callback to run when monitoring has finished. Intended for testing.
   FinishedCallback finished_callback_;
 
-  // The hosts which are in the delegate's queue.
-  std::set<DeferredStartRenderHost*> in_queue_;
+  // The hosts which are waiting to start loading.
+  std::set<const DeferredStartRenderHost*> awaiting_loading_;
   // The hosts which are currently loading.
   std::set<const DeferredStartRenderHost*> active_loading_;
 
   // True if this has started monitoring.
   bool started_;
 
   // Metrics:
   // The total number of hosts that were added to the queue.
   size_t num_queued_;
   // The total number of hosts that started loading.
   size_t num_loaded_;
-  // The maximum number of hosts in the queue at any time.
-  size_t max_in_queue_;
+  // The maximum number of hosts waiting to load at the same time.
+  size_t max_awaiting_loading_;
   // The maximum number of hosts that were loading at the same time.
   size_t max_active_loading_;
 
   base::WeakPtrFactory<LoadMonitoringExtensionHostQueue> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadMonitoringExtensionHostQueue);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_LOAD_MONITORING_EXTENSION_HOST_QUEUE_H_