Add SafeBrowsingNavigationObserver to listen to navigation events

chrome/browser/safe_browsing/safe_browsing_navigation_observer.cc

+// Copyright 2016 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 "chrome/browser/safe_browsing/safe_browsing_navigation_observer.h"
+
+#include "base/memory/ptr_util.h"
+#include "base/time/time.h"
+#include "chrome/browser/safe_browsing/safe_browsing_navigation_observer_manager.h"
+#include "chrome/browser/sessions/session_tab_helper.h"
+#include "content/public/browser/navigation_handle.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/resource_request_details.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/common/resource_type.h"
+
+using content::WebContents;
+
+namespace {
+const char kWebContentsUserDataKey[] =
+    "web_contents_safe_browsing_navigation_observer";
+}  // namespace
+
+namespace safe_browsing {
+
+// SafeBrowsingNavigationObserver::NavigationEvent-----------------------------
+NavigationEvent::NavigationEvent()
+    : source_url(),
+      source_main_frame_url(),
+      original_request_url(),
+      destination_url(),
+      source_tab_id(-1),
+      target_tab_id(-1),
+      frame_id(-1),
+      last_updated(base::Time::Now()),
+      is_user_initiated(false),
+      has_committed(false),
+      has_server_redirect(false) {}
+
+NavigationEvent::NavigationEvent(NavigationEvent&& nav_event)
+    : source_url(std::move(nav_event.source_url)),
+      source_main_frame_url(std::move(nav_event.source_main_frame_url)),
+      original_request_url(std::move(nav_event.original_request_url)),
+      destination_url(std::move(nav_event.destination_url)),
+      source_tab_id(std::move(nav_event.source_tab_id)),
+      target_tab_id(std::move(nav_event.target_tab_id)),
+      frame_id(nav_event.frame_id),
+      last_updated(nav_event.last_updated),
+      is_user_initiated(nav_event.is_user_initiated),
+      has_committed(nav_event.has_committed),
+      has_server_redirect(nav_event.has_server_redirect) {}
+
+NavigationEvent& NavigationEvent::operator=(NavigationEvent&& nav_event) {
+  source_url = std::move(nav_event.source_url);
+  source_main_frame_url = std::move(nav_event.source_main_frame_url);
+  original_request_url = std::move(nav_event.original_request_url);
+  destination_url = std::move(nav_event.destination_url);
+  source_tab_id = nav_event.source_tab_id;
+  target_tab_id = nav_event.target_tab_id;
+  frame_id = nav_event.frame_id;
+  last_updated = nav_event.last_updated;
+  is_user_initiated = nav_event.is_user_initiated;
+  has_committed = nav_event.has_committed;
+  has_server_redirect = nav_event.has_server_redirect;
+  return *this;
+}
+
+NavigationEvent::~NavigationEvent() {}
+
+// SafeBrowsingNavigationObserver --------------------------------------------
+
+// static
+void SafeBrowsingNavigationObserver::MaybeCreateForWebContents(
+    content::WebContents* web_contents) {
+  if (FromWebContents(web_contents))
+    return;
+  // TODO(jialiul): This method will be called by TabHelpers::AttachTabHelpers.
+  // Complete this method when the entire class is ready.
+  NOTIMPLEMENTED();
+}
+
+// static
+SafeBrowsingNavigationObserver* SafeBrowsingNavigationObserver::FromWebContents(
+    content::WebContents* web_contents) {
+  return static_cast<SafeBrowsingNavigationObserver*>(
+      web_contents->GetUserData(kWebContentsUserDataKey));
+}
+
+SafeBrowsingNavigationObserver::SafeBrowsingNavigationObserver(
+    content::WebContents* contents,
+    const scoped_refptr<SafeBrowsingNavigationObserverManager>& manager)
+    : content::WebContentsObserver(contents),
+      manager_(manager),
+      has_user_gesture_(false),
+      last_user_gesture_timestamp_(base::Time()) {}
+
+SafeBrowsingNavigationObserver::~SafeBrowsingNavigationObserver() {}
+
+// Called when a navigation starts in the WebContents. |navigation_handle|
+// parameter is unique to this navigation, which will appear in the following
+// DidRedirectNavigation, and DidFinishNavigation too.
+void SafeBrowsingNavigationObserver::DidStartNavigation(
+    content::NavigationHandle* navigation_handle) {
+  NavigationEvent nav_event;
+  auto it = navigation_handle_map_.find(navigation_handle);
+  // It is possible to see multiple DidStartNavigation(..) with the same
+  // navigation_handle (e.g. cross-process transfer). If that's the case,
+  // we need to copy the is_user_initiated field.
+  if (it != navigation_handle_map_.end()) {
+    nav_event.is_user_initiated = it->second.is_user_initiated;
+  } else {
+    // If this is the first time we see this navigation_handle, create a new
+    // NavigationEvent, and decide if it is triggered by user.
+    if ((has_user_gesture_ &&
+         !SafeBrowsingNavigationObserverManager::IsUserGestureExpired(
+             last_user_gesture_timestamp_)) ||
+        !navigation_handle->IsRendererInitiated()) {
+      nav_event.is_user_initiated = has_user_gesture_;
+      manager_->OnUserGestureConsumed(web_contents(),
+                                      last_user_gesture_timestamp_);
+    }
+    has_user_gesture_ = false;
+  }
+
+  // All the other fields are reconstructed based on current content of
+  // navigation_handle.
+  nav_event.frame_id = navigation_handle->GetFrameTreeNodeId();
+
+  // If there was a URL previously committed in the current RenderFrameHost,
+  // set it as the source url of this navigation. Otherwise, this is the
+  // first url going to commit in this frame. We set navigation_handle's URL as
+  // the source url.
+  // TODO(jialiul): source_url, source_tab_id, and source_main_frame_url may be
+  // incorrect when another frame is targeting this frame. Need to refine this
+  // logic after the true initiator details are added to NavigationHandle
+  // (https://crbug.com/651895).
+  content::RenderFrameHost* current_frame_host =
+      navigation_handle->GetWebContents()->FindFrameByFrameTreeNodeId(
+          nav_event.frame_id);
+  if (current_frame_host &&
+      current_frame_host->GetLastCommittedURL().is_valid()) {
+    nav_event.source_url = SafeBrowsingNavigationObserverManager::ClearEmptyRef(
+        current_frame_host->GetLastCommittedURL());
+  }
+  nav_event.original_request_url =
+      SafeBrowsingNavigationObserverManager::ClearEmptyRef(
+          navigation_handle->GetURL());
+  nav_event.destination_url = nav_event.original_request_url;
+
+  nav_event.source_tab_id =
+      SessionTabHelper::IdForTab(navigation_handle->GetWebContents());
+
+  if (navigation_handle->IsInMainFrame()) {
+    nav_event.source_main_frame_url = nav_event.source_url;
+  } else {
+    nav_event.source_main_frame_url =
+        SafeBrowsingNavigationObserverManager::ClearEmptyRef(
+            navigation_handle->GetWebContents()->GetLastCommittedURL());
+  }
+  navigation_handle_map_[navigation_handle] = std::move(nav_event);
+}
+
+void SafeBrowsingNavigationObserver::DidRedirectNavigation(
+    content::NavigationHandle* navigation_handle) {
+  // We should have already seen this navigation_handle in DidStartNavigation.
+  if (navigation_handle_map_.find(navigation_handle) ==
+      navigation_handle_map_.end()) {
+    NOTREACHED();
+    return;
+  }
+
+  NavigationEvent* nav_event = &navigation_handle_map_[navigation_handle];
+  nav_event->has_server_redirect = true;
+  nav_event->destination_url =
+      SafeBrowsingNavigationObserverManager::ClearEmptyRef(
+          navigation_handle->GetURL());
+  nav_event->last_updated = base::Time::Now();
+}
+
+void SafeBrowsingNavigationObserver::DidFinishNavigation(
+    content::NavigationHandle* navigation_handle) {
+  if (navigation_handle_map_.find(navigation_handle) ==
+      navigation_handle_map_.end()) {
+    NOTREACHED();
+    return;
+  }
+
+  // If it is an error page, we ignore this navigation.
+  if (navigation_handle->IsErrorPage()) {
+    navigation_handle_map_.erase(navigation_handle);
+    return;
+  }
+  NavigationEvent* nav_event = &navigation_handle_map_[navigation_handle];
+
+  nav_event->has_committed = navigation_handle->HasCommitted();
+  nav_event->target_tab_id =
+      SessionTabHelper::IdForTab(navigation_handle->GetWebContents());
+  nav_event->last_updated = base::Time::Now();
+
+  manager_->RecordNavigationEvent(nav_event->destination_url, nav_event);
+  navigation_handle_map_.erase(navigation_handle);
+}
+
+void SafeBrowsingNavigationObserver::DidGetResourceResponseStart(
+    const content::ResourceRequestDetails& details) {
+  // We only care about main frame and sub frame.
+  if (details.resource_type != content::RESOURCE_TYPE_MAIN_FRAME &&
+      details.resource_type != content::RESOURCE_TYPE_SUB_FRAME) {
+    return;
+  }
+  if (!details.url.is_valid() || details.socket_address.IsEmpty())
+    return;
+
+  manager_->RecordHostToIpMapping(details.url.host(),
+                                  details.socket_address.host());
+}
+
+void SafeBrowsingNavigationObserver::DidGetUserInteraction(
+    const blink::WebInputEvent::Type type) {
+  last_user_gesture_timestamp_ = base::Time::Now();
+  has_user_gesture_ = true;
+  // TODO (jialiul): Refine user gesture logic when DidOpenRequestedURL
+  // covers all retargetting cases.
+  manager_->RecordUserGestureForWebContents(web_contents(),
+                                            last_user_gesture_timestamp_);
+}
+
+void SafeBrowsingNavigationObserver::WebContentsDestroyed() {
+  manager_->OnWebContentDestroyed(web_contents());
+  web_contents()->RemoveUserData(kWebContentsUserDataKey);
+  // web_contents is null after this function.
+}
+
+}  // namespace safe_browsing