#include "content/browser/media/capture/web_contents_tracker.h"
#include "base/message_loop/message_loop_proxy.h"
+#include "content/browser/frame_host/render_frame_host_impl.h"
+#include "content/browser/renderer_host/render_widget_host_impl.h"
#include "content/public/browser/browser_thread.h"
-#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_process_host.h"
-#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_widget_host_view.h"
#include "content/public/browser/web_contents.h"
namespace content {
-WebContentsTracker::WebContentsTracker() {}
+WebContentsTracker::WebContentsTracker(bool track_fullscreen_rwh)
+ : track_fullscreen_rwh_(track_fullscreen_rwh),
+ last_target_(NULL) {}
WebContentsTracker::~WebContentsTracker() {
DCHECK(!web_contents()) << "BUG: Still observering!";
DCHECK(message_loop_.get());
callback_ = callback;
- BrowserThread::PostTask(
- BrowserThread::UI, FROM_HERE,
- base::Bind(&WebContentsTracker::LookUpAndObserveWebContents, this,
- render_process_id, main_render_frame_id));
+ if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+ StartObservingWebContents(render_process_id, main_render_frame_id);
+ } else {
+ BrowserThread::PostTask(
+ BrowserThread::UI, FROM_HERE,
+ base::Bind(&WebContentsTracker::StartObservingWebContents, this,
+ render_process_id, main_render_frame_id));
+ }
}
void WebContentsTracker::Stop() {
callback_.Reset();
- BrowserThread::PostTask(
- BrowserThread::UI, FROM_HERE,
- base::Bind(&WebContentsTracker::Observe, this,
- static_cast<WebContents*>(NULL)));
+ if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+ WebContentsObserver::Observe(NULL);
+ } else {
+ BrowserThread::PostTask(
+ BrowserThread::UI, FROM_HERE,
+ base::Bind(&WebContentsTracker::Observe, this,
+ static_cast<WebContents*>(NULL)));
+ }
}
-void WebContentsTracker::OnWebContentsChangeEvent() {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+RenderWidgetHost* WebContentsTracker::GetTargetRenderWidgetHost() const {
+ DCHECK_CURRENTLY_ON(BrowserThread::UI);
WebContents* const wc = web_contents();
- RenderViewHost* const rvh = wc ? wc->GetRenderViewHost() : NULL;
- RenderProcessHost* const rph = rvh ? rvh->GetProcess() : NULL;
-
- const int render_process_id = rph ? rph->GetID() : MSG_ROUTING_NONE;
- const int render_view_id = rvh ? rvh->GetRoutingID() : MSG_ROUTING_NONE;
+ if (!wc)
+ return NULL;
+
+ RenderWidgetHost* rwh = NULL;
+ if (track_fullscreen_rwh_) {
+ RenderWidgetHostView* const view = wc->GetFullscreenRenderWidgetHostView();
+ if (view)
+ rwh = view->GetRenderWidgetHost();
+ }
+ if (!rwh) {
+ RenderFrameHostImpl* const rfh =
+ static_cast<RenderFrameHostImpl*>(wc->GetMainFrame());
+ if (rfh)
+ rwh = rfh->GetRenderWidgetHost();
+ }
+
+ return rwh;
+}
- message_loop_->PostTask(FROM_HERE,
- base::Bind(&WebContentsTracker::MaybeDoCallback, this,
- render_process_id, render_view_id));
+void WebContentsTracker::OnPossibleTargetChange(bool force_callback_run) {
+ DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+ RenderWidgetHost* const rwh = GetTargetRenderWidgetHost();
+ if (rwh == last_target_ && !force_callback_run)
+ return;
+ DVLOG(1) << "Will report target change from RenderWidgetHost@" << last_target_
+ << " to RenderWidgetHost@" << rwh;
+ last_target_ = rwh;
+
+ if (message_loop_->BelongsToCurrentThread()) {
+ MaybeDoCallback(rwh);
+ } else {
+ message_loop_->PostTask(
+ FROM_HERE,
+ base::Bind(&WebContentsTracker::MaybeDoCallback, this, rwh));
+ }
}
-void WebContentsTracker::MaybeDoCallback(int render_process_id,
- int render_view_id) {
+void WebContentsTracker::MaybeDoCallback(RenderWidgetHost* rwh) {
DCHECK(message_loop_->BelongsToCurrentThread());
if (!callback_.is_null())
- callback_.Run(render_process_id, render_view_id);
+ callback_.Run(rwh);
}
-void WebContentsTracker::LookUpAndObserveWebContents(int render_process_id,
- int main_render_frame_id) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+void WebContentsTracker::StartObservingWebContents(int render_process_id,
+ int main_render_frame_id) {
+ DCHECK_CURRENTLY_ON(BrowserThread::UI);
Observe(WebContents::FromRenderFrameHost(RenderFrameHost::FromID(
render_process_id, main_render_frame_id)));
<< "referenced by render_process_id=" << render_process_id
<< ", routing_id=" << main_render_frame_id;
- OnWebContentsChangeEvent();
+ OnPossibleTargetChange(true);
+}
+
+void WebContentsTracker::RenderFrameDeleted(
+ RenderFrameHost* render_frame_host) {
+ OnPossibleTargetChange(false);
}
-void WebContentsTracker::RenderViewReady() {
- OnWebContentsChangeEvent();
+void WebContentsTracker::RenderFrameHostChanged(RenderFrameHost* old_host,
+ RenderFrameHost* new_host) {
+ OnPossibleTargetChange(false);
}
-void WebContentsTracker::AboutToNavigateRenderView(RenderViewHost* rvh) {
- OnWebContentsChangeEvent();
+void WebContentsTracker::WebContentsDestroyed() {
+ Observe(NULL);
+ OnPossibleTargetChange(false);
}
-void WebContentsTracker::DidNavigateMainFrame(
- const LoadCommittedDetails& details, const FrameNavigateParams& params) {
- OnWebContentsChangeEvent();
+void WebContentsTracker::DidShowFullscreenWidget(int routing_id) {
+ OnPossibleTargetChange(false);
}
-void WebContentsTracker::WebContentsDestroyed() {
- OnWebContentsChangeEvent();
+void WebContentsTracker::DidDestroyFullscreenWidget(int routing_id) {
+ OnPossibleTargetChange(false);
}
} // namespace content