Reland of PlzNavigate: send SourceLocation when mixed content is found

third_party/WebKit/Source/core/loader/MixedContentChecker.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 203 matching lines @@
   // No mixed content, no problem.
   return nullptr;
 }
 
 // static
 void MixedContentChecker::logToConsoleAboutFetch(
     LocalFrame* frame,
     const KURL& mainResourceUrl,
     const KURL& url,
     WebURLRequest::RequestContext requestContext,
-    bool allowed) {
+    bool allowed,
+    std::unique_ptr<SourceLocation> sourceLocation) {
   String message = String::format(
       "Mixed Content: The page at '%s' was loaded over HTTPS, but requested an "
       "insecure %s '%s'. %s",
       mainResourceUrl.elidedString().utf8().data(),
       requestContextName(requestContext), url.elidedString().utf8().data(),
       allowed ? "This content should also be served over HTTPS."
               : "This request has been blocked; the content must be served "
                 "over HTTPS.");
   MessageLevel messageLevel = allowed ? WarningMessageLevel : ErrorMessageLevel;
-  frame->document()->addConsoleMessage(
-      ConsoleMessage::create(SecurityMessageSource, messageLevel, message));
+  if (sourceLocation) {
+    frame->document()->addConsoleMessage(
+        ConsoleMessage::create(SecurityMessageSource, messageLevel, message,
+                               std::move(sourceLocation)));
+  } else {
+    frame->document()->addConsoleMessage(
+        ConsoleMessage::create(SecurityMessageSource, messageLevel, message));
+  }
 }
 
 // static
 void MixedContentChecker::count(Frame* frame,
                                 WebURLRequest::RequestContext requestContext) {
   UseCounter::count(frame, UseCounter::MixedContentPresent);
 
   // Roll blockable content up into a single counter, count unblocked types
   // individually so we can determine when they can be safely moved to the
   // blockable category:
@@ skipping 143 matching lines @@
       if (allowed)
         client->didDisplayInsecureContent();
       break;
     case WebMixedContentContextType::NotMixedContent:
       NOTREACHED();
       break;
   };
 
   if (reportingPolicy == SecurityViolationReportingPolicy::Report) {
     logToConsoleAboutFetch(frame, mainResourceUrlForFrame(mixedFrame), url,
-                           requestContext, allowed);
+                           requestContext, allowed, nullptr);
   }
   return !allowed;
 }
 
 // static
 void MixedContentChecker::logToConsoleAboutWebSocket(
     LocalFrame* frame,
     const KURL& mainResourceUrl,
     const KURL& url,
     bool allowed) {
@@ skipping 161 matching lines @@
   }
 }
 
 // static
 void MixedContentChecker::mixedContentFound(
     LocalFrame* frame,
     const KURL& mainResourceUrl,
     const KURL& mixedContentUrl,
     WebURLRequest::RequestContext requestContext,
     bool wasAllowed,
-    bool hadRedirect) {
+    bool hadRedirect,
+    std::unique_ptr<SourceLocation> sourceLocation) {
   // Logs to the frame console.
   logToConsoleAboutFetch(frame, mainResourceUrl, mixedContentUrl,
-                         requestContext, wasAllowed);
+                         requestContext, wasAllowed, std::move(sourceLocation));
   // Reports to the CSP policy.
   ContentSecurityPolicy* policy =
       frame->securityContext()->contentSecurityPolicy();
   if (policy) {
     policy->reportMixedContent(
         mixedContentUrl, hadRedirect
                              ? ResourceRequest::RedirectStatus::FollowedRedirect
                              : ResourceRequest::RedirectStatus::NoRedirect);
   }
 }
@@ skipping 18 matching lines @@
   }
 
   bool strictMixedContentCheckingForPlugin =
       mixedFrame->settings() &&
       mixedFrame->settings()->getStrictMixedContentCheckingForPlugin();
   return WebMixedContent::contextTypeFromRequestContext(
       request.requestContext(), strictMixedContentCheckingForPlugin);
 }
 
 }  // namespace blink