Pass the id of the extension which blocked BFCache to devtools.

The goal is to display it in the UI.

This allows attaching an arbitrary string to a BFCache blocking reason.
The string is treated as opaque data by content/ allowing chrome/
to pass data to devtools without breaking layering.

Bug: 1284548
Change-Id: Ibd28032682d0797c30676c29502be388c1e8cb92
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3445921
Reviewed-by: Danil Somsikov <dsv@chromium.org>
Reviewed-by: Devlin Cronin <rdevlin.cronin@chromium.org>
Reviewed-by: Minoru Chikamune <chikamune@chromium.org>
Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Reviewed-by: Alex Moshchuk <alexmos@chromium.org>
Commit-Queue: Fergal Daly <fergal@chromium.org>
Cr-Commit-Position: refs/heads/main@{#974986}

components/back_forward_cache/back_forward_cache_disable.cc

@@ -45,10 +45,11 @@ std::string ReasonIdToString(DisabledReasonId reason_id) {
 }
 
 content::BackForwardCache::DisabledReason DisabledReason(
-    DisabledReasonId reason_id) {
+    DisabledReasonId reason_id,
+    const std::string& context) {
   return content::BackForwardCache::DisabledReason(
       {content::BackForwardCache::DisabledSource::kEmbedder,
        static_cast<content::BackForwardCache::DisabledReasonType>(reason_id),
-       ReasonIdToString(reason_id)});
+       ReasonIdToString(reason_id), context});
 }
 }  // namespace back_forward_cache

components/back_forward_cache/back_forward_cache_disable.h

@@ -12,7 +12,8 @@
 namespace back_forward_cache {
 // Constructs a chrome-specific DisabledReason
 content::BackForwardCache::DisabledReason DisabledReason(
-    DisabledReasonId reason_id);
+    DisabledReasonId reason_id,
+    const std::string& context = "");
 }  // namespace back_forward_cache
 
 #endif  // COMPONENTS_BACK_FORWARD_CACHE_BACK_FORWARD_CACHE_DISABLE_H_

content/browser/devtools/protocol/page_handler.cc

@@ -1792,13 +1792,16 @@ CreateNotRestoredExplanation(
     } else if (reason == BackForwardCacheMetrics::NotRestoredReason::
                              kDisableForRenderFrameHostCalled) {
       for (auto disabled_reason : disabled_reasons) {
-        reasons->emplace_back(
+        auto reason =
             Page::BackForwardCacheNotRestoredExplanation::Create()
                 .SetType(
                     MapDisableForRenderFrameHostReasonToType(disabled_reason))
                 .SetReason(
                     DisableForRenderFrameHostReasonToProtocol(disabled_reason))
-                .Build());
+                .Build();
+        if (!disabled_reason.context.empty())
+          reason->SetContext(disabled_reason.context);
+        reasons->emplace_back(std::move(reason));
       }
     } else {
       reasons->emplace_back(

content/browser/renderer_host/back_forward_cache_can_store_document_result.cc

@@ -238,8 +238,9 @@ std::string DisabledReasonsToString(
     const std::set<BackForwardCache::DisabledReason>& reasons) {
   std::vector<std::string> descriptions;
   for (const auto& reason : reasons) {
-    descriptions.push_back(base::StringPrintf(
-        "%d:%d:%s", reason.source, reason.id, reason.description.c_str()));
+    descriptions.push_back(
+        base::StringPrintf("%d:%d:%s:%s", reason.source, reason.id,
+                           reason.description.c_str(), reason.context.c_str()));
   }
   return base::JoinString(descriptions, ", ");
 }

content/public/browser/back_forward_cache.h

@@ -51,13 +51,16 @@ class CONTENT_EXPORT BackForwardCache {
   typedef uint16_t DisabledReasonType;
   static const uint16_t kDisabledReasonTypeBits = 16;
 
-  // Represents a reason to disable back-forward cache, given by a source. It
-  // preserves the string that accompanied it, however the string is ignored for
-  // <, == and !=.
+  // Represents a reason to disable back-forward cache, given by a |source|.
+  // |context| is arbitrary context that will be preserved and passed through,
+  // e.g. an extension ID responsible for disabling BFCache that can be shown in
+  // passed devtools. It preserves the |description| and |context| that
+  // accompany it, however they are ignored for <, == and !=.
   struct CONTENT_EXPORT DisabledReason {
     const BackForwardCache::DisabledSource source;
     const BackForwardCache::DisabledReasonType id;
     const std::string description;
+    const std::string context;
 
     bool operator<(const DisabledReason&) const;
     bool operator==(const DisabledReason&) const;

extensions/browser/api/messaging/extension_message_port.cc

@@ -449,19 +449,27 @@ void ExtensionMessagePort::SendToPort(IPCBuilderCallback ipc_builder) {
 
   for (const IPCTarget& target : targets) {
     // Frames in the BackForwardCache are not allowed to receive messages (or
-    // even have them queued). In such a case, we evict the frame from the cache
+    // even have them queued). In such a case, we evict the page from the cache
     // and "drop" the message (See comment in `DidFinishNavigation()`).
     // Note: Since this will cause the frame to be deleted, we do this here
     // instead of in the loop above to avoid modifying `frames_` while it is
     // being iterated.
+    //
+    // This could cause the same page to be evicted multiple times if it has
+    // multiple frames receiving this message. This is harmless as the reason is
+    // the same in every case. Also multiple extensions may send messages before
+    // the page is actually evicted. The last one will be the one the user
+    // sees. It is not worth the effort to present all of them to the user. It's
+    // unlikely they will see the same one every time and if they do, when they
+    // fix that one, they will see the others.
     if (target.render_frame_host &&
         target.render_frame_host->GetLifecycleState() ==
             content::RenderFrameHost::LifecycleState::kInBackForwardCache) {
       content::BackForwardCache::DisableForRenderFrameHost(
-          target.render_frame_host,
-          back_forward_cache::DisabledReason(
-              back_forward_cache::DisabledReasonId::
-                  kExtensionSentMessageToCachedFrame));
+          target.render_frame_host, back_forward_cache::DisabledReason(
+                                        back_forward_cache::DisabledReasonId::
+                                            kExtensionSentMessageToCachedFrame,
+                                        /*context=*/extension_id_));
       continue;
     }
 

third_party/blink/public/devtools_protocol/browser_protocol.pdl

@@ -8207,6 +8207,11 @@ domain Page
       BackForwardCacheNotRestoredReasonType type
       # Not restored reason
       BackForwardCacheNotRestoredReason reason
+      # Context associated with the reason. The meaning of this context is
+      # dependent on the reason:
+      # - EmbedderExtensionSentMessageToCachedFrame: the extension ID.
+      #
+      optional string context
 
   experimental type BackForwardCacheNotRestoredExplanationTree extends object
     properties