Implement frame attribution (FrameBlamer)

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 11 matching lines @@
 #include "base/memory/shared_memory.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/process/process.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#include "base/trace_event/trace_event_argument.h"
 #include "build/build_config.h"
 #include "cc/base/switches.h"
 #include "components/scheduler/renderer/renderer_scheduler.h"
 #include "content/child/appcache/appcache_dispatcher.h"
 #include "content/child/permissions/permission_dispatcher.h"
 #include "content/child/plugin_messages.h"
 #include "content/child/quota_dispatcher.h"
 #include "content/child/request_extra_data.h"
 #include "content/child/service_worker/service_worker_handle_reference.h"
 #include "content/child/service_worker/service_worker_network_provider.h"
@@ skipping 972 matching lines @@
       geolocation_dispatcher_(NULL),
       push_messaging_dispatcher_(NULL),
       presentation_dispatcher_(NULL),
       screen_orientation_dispatcher_(NULL),
       manifest_manager_(NULL),
       accessibility_mode_(AccessibilityModeOff),
       renderer_accessibility_(NULL),
       media_player_delegate_(NULL),
       is_using_lofi_(false),
       is_pasting_(false),
+      trace_object_("blink",
+                    "RenderFrameImpl",
+                    TRACE_ID_WITH_SCOPE("RenderFrameImpl", params.routing_id)),
       weak_factory_(this) {
   std::pair<RoutingIDFrameMap::iterator, bool> result =
       g_routing_id_frame_map.Get().insert(std::make_pair(routing_id_, this));
   CHECK(result.second) << "Inserting a duplicate item.";
 
   RenderThread::Get()->AddRoute(routing_id_, this);
 
   render_view_->RegisterRenderFrame(this);
 
   // Everything below subclasses RenderFrameObserver and is automatically
   // deleted when the RenderFrame gets deleted.
 #if defined(OS_ANDROID)
   new GinJavaBridgeDispatcher(this);
 #endif
 
 #if defined(ENABLE_PLUGINS)
   // Manages its own lifetime.
   plugin_power_saver_helper_ = new PluginPowerSaverHelper(this);
 #endif
 
   manifest_manager_ = new ManifestManager(this);
+
+  base::trace_event::TraceLog::GetInstance()->AddEnabledStateObserver(this);
 }
 
 RenderFrameImpl::~RenderFrameImpl() {
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, RenderFrameGone());
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, OnDestruct());
 
   base::trace_event::TraceLog::GetInstance()->RemoveProcessLabel(routing_id_);
+  base::trace_event::TraceLog::GetInstance()->RemoveEnabledStateObserver(this);
 
 #if defined(VIDEO_HOLE)
   if (contains_media_player_)
     render_view_->UnregisterVideoHoleFrame(this);
 #endif
 
   if (is_main_frame_) {
     // When using swapped out frames, RenderFrameProxy is owned by
     // RenderFrameImpl in the case it is the main frame. Ensure it is deleted
     // along with this object.
@@ skipping 25 matching lines @@
   CHECK(result.second) << "Inserting a duplicate item.";
 
   frame_ = web_frame;
 }
 
 void RenderFrameImpl::Initialize() {
   is_main_frame_ = !frame_->parent();
 
   RenderFrameImpl* parent_frame = RenderFrameImpl::FromWebFrame(
       frame_->parent());
-  if (parent_frame)
+  if (parent_frame) {
     is_using_lofi_ = parent_frame->IsUsingLoFi();
+    blame_context_ = make_scoped_ptr(new RenderFrameBlameContext(
+        routing_id_, *parent_frame->blame_context_));
+  } else {
+    blame_context_ = make_scoped_ptr(new RenderFrameBlameContext(
+        routing_id_, *RenderThreadImpl::current()->blame_context()));
+  }
+  web_blame_context_ =
+      make_scoped_ptr(new WebBlameContextImpl(blame_context_.get()));
+  blame_context_->TakeSnapshot();
 
   bool is_tracing = false;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED("navigation", &is_tracing);
   if (is_tracing) {
     int parent_id = GetRoutingIdForFrameOrProxy(frame_->parent());
     TRACE_EVENT2("navigation", "RenderFrameImpl::Initialize",
                  "id", routing_id_,
                  "parent", parent_id);
   }
 
   if (IsMainFrame() &&
       RenderProcess::current()->GetEnabledBindings() & BINDINGS_POLICY_WEB_UI) {
     EnableMojoBindings(false /* for_layout_tests */);
   }
 
 #if defined(ENABLE_PLUGINS)
   new PepperBrowserConnection(this);
 #endif
   new SharedWorkerRepository(this);
 
   if (IsLocalRoot() && !is_swapped_out_) {
     // DevToolsAgent is a RenderFrameObserver, and will destruct itself
     // when |this| is deleted.
     devtools_agent_ = new DevToolsAgent(this);
   }
 
   RegisterMojoServices();
+  TraceSnapshot();
 
   // We delay calling this until we have the WebFrame so that any observer or
   // embedder can call GetWebFrame on any RenderFrame.
   GetContentClient()->renderer()->RenderFrameCreated(this);
 }
 
 RenderWidget* RenderFrameImpl::GetRenderWidget() {
   RenderFrameImpl* local_root =
       RenderFrameImpl::FromWebFrame(frame_->localRoot());
   return local_root->render_widget_.get();
@@ skipping 1443 matching lines @@
   return external_popup_menu_.get();
 #else
   return NULL;
 #endif
 }
 
 blink::WebCookieJar* RenderFrameImpl::cookieJar() {
   return &cookie_jar_;
 }
 
+blink::WebBlameContext* RenderFrameImpl::frameBlameContext() {
+  return web_blame_context_.get();
+}
+
 blink::WebServiceWorkerProvider*
 RenderFrameImpl::createServiceWorkerProvider() {
   // At this point we should have non-null data source.
   DCHECK(frame_->dataSource());
   if (!ChildThreadImpl::current())
     return nullptr;  // May be null in some tests.
   ServiceWorkerNetworkProvider* provider =
       ServiceWorkerNetworkProvider::FromDocumentState(
           DocumentState::FromDataSource(frame_->dataSource()));
   DCHECK(provider);
@@ skipping 3517 matching lines @@
 void RenderFrameImpl::SendFindReply(int request_id,
                                     int match_count,
                                     int ordinal,
                                     const WebRect& selection_rect,
                                     bool final_status_update) {
   Send(new FrameHostMsg_Find_Reply(routing_id_, request_id, match_count,
                                    selection_rect, ordinal,
                                    final_status_update));
 }
 
+void RenderFrameImpl::OnTraceLogEnabled() {
+  TraceSnapshot();
+}
+
+void RenderFrameImpl::OnTraceLogDisabled() {}
+
+void RenderFrameImpl::TraceSnapshot() const {
+  bool is_tracing = false;
+  TRACE_EVENT_CATEGORY_GROUP_ENABLED("blink", &is_tracing);
+  if (!is_tracing || !frame_)
+    return;
+
+  scoped_refptr<base::trace_event::TracedValue> state =
+      new base::trace_event::TracedValue();
+  state->BeginDictionary("frame");
+  state->SetString("id_ref",
+                   base::StringPrintf("0x%" PRIx64, frame_->frameID()));
+  state->SetString("scope", "blink::Frame");
+  state->EndDictionary();
+  state->SetInteger("routing_id", routing_id_);
+  scoped_refptr<base::trace_event::ConvertableToTraceFormat> snapshot_data(
+      state);
+  trace_object_.Snapshot(snapshot_data);
+}
+
 }  // namespace content