Plumb site engagement to the renderer process.

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 1087 matching lines @@
       is_using_lofi_(false),
       effective_connection_type_(
           blink::WebEffectiveConnectionType::TypeUnknown),
       is_pasting_(false),
       suppress_further_dialogs_(false),
       blame_context_(nullptr),
 #if BUILDFLAG(ENABLE_PLUGINS)
       focused_pepper_plugin_(nullptr),
       pepper_last_mouse_event_target_(nullptr),
 #endif
+      engagement_binding_(this),
       frame_binding_(this),
       host_zoom_binding_(this),
       has_accessed_initial_document_(false),
       weak_factory_(this) {
   // We don't have a service_manager::Connection at this point, so use empty
   // identity/specs.
   // TODO(beng): We should fix this, so we can apply policy about which
   //             interfaces get exposed.
   interface_registry_ = base::MakeUnique<service_manager::InterfaceRegistry>(
       mojom::kNavigation_FrameSpec);
@@ skipping 504 matching lines @@
   // Can be NULL in tests.
   if (render_thread_impl)
     render_thread_impl->GetRendererScheduler()->OnNavigationStarted();
   DCHECK(!IsBrowserSideNavigationEnabled());
   TRACE_EVENT2("navigation,rail", "RenderFrameImpl::OnNavigate", "id",
                routing_id_, "url", common_params.url.possibly_invalid_spec());
   NavigateInternal(common_params, start_params, request_params,
                    std::unique_ptr<StreamOverrideParameters>());
 }
 
-void RenderFrameImpl::Bind(mojom::FrameRequest request,
-                           mojom::FrameHostPtr host) {
+void RenderFrameImpl::BindEngagement(
+    blink::mojom::EngagementClientAssociatedRequest request) {
+  engagement_binding_.Bind(std::move(request));
+}
+
+void RenderFrameImpl::BindFrame(mojom::FrameRequest request,
+                                mojom::FrameHostPtr host) {
   frame_binding_.Bind(std::move(request));
   frame_host_ = std::move(host);
   frame_host_->GetInterfaceProvider(
       std::move(pending_remote_interface_provider_request_));
 }
 
 ManifestManager* RenderFrameImpl::manifest_manager() {
   return manifest_manager_;
 }
 
@@ skipping 995 matching lines @@
 }
 
 bool RenderFrameImpl::IsUsingLoFi() const {
   return is_using_lofi_;
 }
 
 bool RenderFrameImpl::IsPasting() const {
   return is_pasting_;
 }
 
+// blink::mojom::EngagementClient implementation -------------------------------
+
+void RenderFrameImpl::SetEngagementLevel(const url::Origin& origin,
+                                         blink::mojom::EngagementLevel level) {
+  // Set the engagement level on |frame_| if we have committed the current
+  // navigation. Otherwise, it will be set in didCommitProvisionalLoad.
+  if (frame_ && frame_->dataSource()) {
+    NavigationStateImpl* navigation_state = static_cast<NavigationStateImpl*>(
+        DocumentState::FromDataSource(frame_->dataSource())
+            ->navigation_state());
+    if (navigation_state->request_committed() &&
+        url::Origin(frame_->getSecurityOrigin()) == origin) {
+      frame_->setEngagementLevel(level);
+      return;
+    }

[nasko, 2016/11/30 18:00:25]

This seems like lots of complex logic. Why can't we just simply ask the frame
for the origin of its current security context?

Between always setting the level if the frame current origin matches or saving
it otherwise and always setting it at commit time if found in the map, it should
cover all the cases. Let me know if I've missed some.

[dominickn, 2016/11/30 23:46:33]

I'm definitely not an expert on this (hence the complexity!), so I can't confirm
if this covers all the cases. But I'm more than happy to defer. :)

+  }
+
+  engagement_levels_[origin] = level;

[nasko, 2016/11/30 18:00:25]

Do we need to store the level in the map if it was already set on the frame?

[dominickn, 2016/11/30 23:46:33]

I don't think so - that's why it returns immediately after setting it on the
frame above.

+}
+
 // mojom::Frame implementation -------------------------------------------------
 
 void RenderFrameImpl::GetInterfaceProvider(
     service_manager::mojom::InterfaceProviderRequest request) {
   service_manager::ServiceInfo child_info =
       ChildThreadImpl::current()->GetChildServiceInfo();
   service_manager::ServiceInfo browser_info =
       ChildThreadImpl::current()->GetBrowserServiceInfo();
 
   service_manager::InterfaceProviderSpec child_spec, browser_spec;
@@ skipping 2066 matching lines @@
 
   const WebURLRequest& request = ds->request();
   const WebURLResponse& response = ds->response();
 
   DocumentState* document_state = DocumentState::FromDataSource(ds);
   NavigationStateImpl* navigation_state =
       static_cast<NavigationStateImpl*>(document_state->navigation_state());
   InternalDocumentStateData* internal_data =
       InternalDocumentStateData::FromDocumentState(document_state);
 
+  // Set the correct engagement level on the frame.
+  EngagementLevels::iterator engagement_level =
+      engagement_levels_.find(url::Origin(GURL(request.url())));

[nasko, 2016/11/30 18:00:25]

Can't we use the frame's origin at this point? Why go through this elaborate
conversion, which actually is lossy too?

[dominickn, 2016/11/30 23:46:33]

Done.

+
+  if (engagement_level != engagement_levels_.end()) {
+    frame_->setEngagementLevel(engagement_level->second);
+    engagement_levels_.erase(engagement_level);

[nasko, 2016/11/30 18:00:25]

The map should never grow big, right? Maybe add some form of a (D)CHECK to
ensure we don't leak? Or alternatively purge the map at commit.

[dominickn, 2016/11/30 23:46:33]

Done - instead of erasing, I just cleared the map immediately after this.

+  }
+
   FrameHostMsg_DidCommitProvisionalLoad_Params params;
   params.http_status_code = response.httpStatusCode();
   params.url_is_unreachable = ds->hasUnreachableURL();
   params.method = "GET";
   params.intended_as_new_entry =
       navigation_state->request_params().intended_as_new_entry;
   params.did_create_new_entry = commit_type == blink::WebStandardCommit;
   params.should_replace_current_entry = ds->replacesCurrentHistoryItem();
   params.post_id = -1;
   params.nav_entry_id = navigation_state->request_params().nav_entry_id;
@@ skipping 1732 matching lines @@
     // Mimics the order of events sent by WebKit.
     // See WebCore::Editor::setComposition() for the corresponding code.
     focused_pepper_plugin_->HandleCompositionEnd(text);
     focused_pepper_plugin_->HandleTextInput(text);
   }
   pepper_composition_text_.clear();
 }
 #endif  // ENABLE_PLUGINS
 
 void RenderFrameImpl::RegisterMojoInterfaces() {
+  GetAssociatedInterfaceRegistry()->AddInterface(
+      base::Bind(&RenderFrameImpl::BindEngagement, weak_factory_.GetWeakPtr()));
+
   if (!frame_->parent()) {
     // Only main frame have ImageDownloader service.
     GetInterfaceRegistry()->AddInterface(base::Bind(
         &ImageDownloaderImpl::CreateMojoService, base::Unretained(this)));
 
     // Host zoom is per-page, so only added on the main frame.
     GetAssociatedInterfaceRegistry()->AddInterface(base::Bind(
         &RenderFrameImpl::OnHostZoomClientRequest, weak_factory_.GetWeakPtr()));
   }
 }
@@ skipping 170 matching lines @@
   // event target. Potentially a Pepper plugin will receive the event.
   // In order to tell whether a plugin gets the last mouse event and which it
   // is, we set |pepper_last_mouse_event_target_| to null here. If a plugin gets
   // the event, it will notify us via DidReceiveMouseEvent() and set itself as
   // |pepper_last_mouse_event_target_|.
   pepper_last_mouse_event_target_ = nullptr;
 #endif
 }
 
 }  // namespace content