PlzNavigate: Release StreamHandle.

content/renderer/render_frame_impl.cc

 // Copyright 2013 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/render_frame_impl.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 5108 matching lines @@
 
   for (auto& observer : observers_)
     observer.FocusedNodeChanged(node);
 }
 
 void RenderFrameImpl::FocusedNodeChangedForAccessibility(const WebNode& node) {
   if (render_accessibility())
     render_accessibility()->AccessibilityFocusedNodeChanged(node);
 }
 
+// PlzNavigate: Used to delete the StreamHandle that live on the browser side.
+class StreamHandleDeleter : public RenderFrameObserver {
+ public:
+  StreamHandleDeleter(RenderFrame* render_frame)
+      : RenderFrameObserver(render_frame) {}
+  void OnDestruct() override {}
+  void OnStreamHandleConsumed(const GURL& stream_handle_url) {
+    if (!render_frame())
+      return;
+    static_cast<RenderFrameImpl*>(render_frame())
+        ->StreamHandleConsumed(stream_handle_url);
+  }
+};
+
 // PlzNavigate
 void RenderFrameImpl::OnCommitNavigation(
     const ResourceResponseHead& response,
     const GURL& stream_url,
     const FrameMsg_CommitDataNetworkService_Params& commit_data,
     const CommonNavigationParams& common_params,
     const RequestNavigationParams& request_params) {
   CHECK(IsBrowserSideNavigationEnabled());
   // This will override the url requested by the WebURLLoader, as well as
   // provide it with the response to the request.
   std::unique_ptr<StreamOverrideParameters> stream_override(
       new StreamOverrideParameters());
   stream_override->stream_url = stream_url;
   stream_override->consumer_handle =
       mojo::ScopedDataPipeConsumerHandle(commit_data.handle);
   stream_override->response = response;
   stream_override->redirects = request_params.redirects;
   stream_override->redirect_responses = request_params.redirect_response;
   stream_override->redirect_infos = request_params.redirect_infos;
 
+  // PlzNavigate: Notify the browser that it can released its |stream_handle_|
+  // when the |stream_override| object is no more used. This is a temporary
+  // solution until mojo is used.
+  stream_override->on_delete = base::BindOnce(
+      [](std::unique_ptr<StreamHandleDeleter> stream_handle_deleter,
+         const GURL& url) {
+        stream_handle_deleter->OnStreamHandleConsumed(url);

[clamy, 2017/06/09 14:57:42]

Why not binding the RenderFrameImpl directly with this RenderFrameImpl as a
weak_ptr?

[arthursonzogni, 2017/06/12 09:30:15]

I thought base::weak_ptr was sort of the the same thing as std::weak_ptr. That
meant I would need the RenderFrameHostImpl lifetime to be managed by an
std::shared_ptr equivalent.

So yes, base::weak_ptr is the right tool here thanks!

+      },
+      base::MakeUnique<StreamHandleDeleter>(this));
+
   if (commit_data.url_loader_factory.is_valid()) {
     // Chrome doesn't use interface versioning.
     url_loader_factory_.Bind(mojom::URLLoaderFactoryPtrInfo(
         mojo::ScopedMessagePipeHandle(commit_data.url_loader_factory), 0u));
   }
 
   // If the request was initiated in the context of a user gesture then make
   // sure that the navigation also executes in the context of a user gesture.
   std::unique_ptr<blink::WebScopedUserGesture> gesture(
       request_params.has_user_gesture ? new blink::WebScopedUserGesture(frame_)
@@ skipping 1083 matching lines @@
       selection_range_ != range ||
       selection_text_ != text) {
     selection_text_ = text;
     selection_text_offset_ = offset;
     selection_range_ = range;
     SetSelectedText(text, offset, range);
   }
   GetRenderWidget()->UpdateSelectionBounds();
 }
 
+void RenderFrameImpl::StreamHandleConsumed(const GURL& stream_url) {
+  Send(new FrameHostMsg_StreamHandleConsumed(routing_id_, stream_url));
+}
+
 void RenderFrameImpl::InitializeUserMediaClient() {
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   if (!render_thread)  // Will be NULL during unit tests.
     return;
 
 #if BUILDFLAG(ENABLE_WEBRTC)
   DCHECK(!web_user_media_client_);
   web_user_media_client_ = new UserMediaClientImpl(
       this, RenderThreadImpl::current()->GetPeerConnectionDependencyFactory(),
       base::MakeUnique<MediaStreamDispatcher>(this),
@@ skipping 596 matching lines @@
       policy(info.default_policy),
       replaces_current_history_item(info.replaces_current_history_item),
       history_navigation_in_new_child_frame(
           info.is_history_navigation_in_new_child_frame),
       client_redirect(info.is_client_redirect),
       cache_disabled(info.is_cache_disabled),
       form(info.form),
       source_location(info.source_location) {}
 
 }  // namespace content