Add interface for clearing the code cache entry

Add support in blink::Platform and RenderMessageFilter to
clear the code cache entry.

Bug: chromium:812168
Change-Id: Ida83f17443f70d1cfbc83236f08628f0820a5cf7
Reviewed-on: https://chromium-review.googlesource.com/1160234
Commit-Queue: Mythri Alle <mythria@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Cr-Commit-Position: refs/heads/master@{#585397}

content/browser/renderer_host/render_message_filter.cc

@@ -92,6 +92,26 @@ const uint32_t kRenderFilteredMessageClasses[] = {ViewMsgStart};
 void NoOpCacheStorageErrorCallback(CacheStorageCacheHandle cache_handle,
                                    CacheStorageError error) {}
 
+base::Optional<url::Origin> GetRendererOrigin(const GURL& url,
+                                              int render_process_id) {
+  GURL requesting_url =
+      ChildProcessSecurityPolicyImpl::GetInstance()->GetOriginLock(
+          render_process_id);
+
+  if (!requesting_url.is_valid() || !url.is_valid())
+    return base::nullopt;
+
+  url::Origin origin = url::Origin::Create(requesting_url);
+
+  // Don't cache the code corresponding to unique origins. The same-origin
+  // checks should always fail for unique origins but the serialized value of
+  // unique origins does not ensure this.
+  if (origin.unique())
+    return base::nullopt;
+
+  return origin;
+}
+
 }  // namespace
 
 RenderMessageFilter::RenderMessageFilter(
@@ -237,45 +257,35 @@ void RenderMessageFilter::DidGenerateCacheableMetadata(
     cache->WriteMetadata(url, kPriority, expected_response_time, buf.get(),
                          data.size());
   } else {
-    GURL requesting_url =
-        ChildProcessSecurityPolicyImpl::GetInstance()->GetOriginLock(
-            render_process_id_);
-    // If the origin_url isn't valid then render process might not be locked to
-    // an origin yet so we don't allow any writes to the disk.
-    if (!requesting_url.is_valid() || !url.is_valid())
+    if (!generated_code_cache_context_->generated_code_cache())
       return;
-    url::Origin requesting_origin = url::Origin::Create(requesting_url);
 
-    // Don't cache the code corresponding to unique origins. The same-origin
-    // checks should always fail for unique origins but the serialized value of
-    // unique origins does not ensure this.
-    if (requesting_origin.unique())
+    base::Optional<url::Origin> requesting_origin =
+        GetRendererOrigin(url, render_process_id_);
+    if (!requesting_origin)
       return;
 
     generated_code_cache_context_->generated_code_cache()->WriteData(
-        url, requesting_origin, expected_response_time, data);
+        url, *requesting_origin, expected_response_time, data);
   }
 }
 
 void RenderMessageFilter::FetchCachedCode(const GURL& url,
                                           FetchCachedCodeCallback callback) {
-  GURL requesting_url =
-      ChildProcessSecurityPolicyImpl::GetInstance()->GetOriginLock(
-          render_process_id_);
-  // If the url isn't valid then render process may not be locked to an origin
-  // yet so we don't allow fetches from code cache.
-  if (!requesting_url.is_valid() || !url.is_valid()) {
-    std::move(callback).Run(base::Time(), std::vector<uint8_t>());
+  if (!generated_code_cache_context_->generated_code_cache())
+    return;
+
+  base::Optional<url::Origin> requesting_origin =
+      GetRendererOrigin(url, render_process_id_);
+  if (!requesting_origin)
     return;
-  }
 
-  url::Origin requesting_origin = url::Origin::Create(requesting_url);
   base::RepeatingCallback<void(const base::Time&, const std::vector<uint8_t>&)>
       read_callback = base::BindRepeating(
           &RenderMessageFilter::OnReceiveCachedCode,
           weak_ptr_factory_.GetWeakPtr(), base::Passed(&callback));
   generated_code_cache_context_->generated_code_cache()->FetchEntry(
-      url, requesting_origin, read_callback);
+      url, *requesting_origin, read_callback);
 }
 
 void RenderMessageFilter::OnReceiveCachedCode(
@@ -287,6 +297,19 @@ void RenderMessageFilter::OnReceiveCachedCode(
   std::move(callback).Run(response_time, data);
 }
 
+void RenderMessageFilter::ClearCodeCacheEntry(const GURL& url) {
+  if (!generated_code_cache_context_->generated_code_cache())
+    return;
+
+  base::Optional<url::Origin> requesting_origin =
+      GetRendererOrigin(url, render_process_id_);
+  if (!requesting_origin)
+    return;
+
+  generated_code_cache_context_->generated_code_cache()->DeleteEntry(
+      url, *requesting_origin);
+}
+
 void RenderMessageFilter::DidGenerateCacheableMetadataInCacheStorage(
     const GURL& url,
     base::Time expected_response_time,

content/browser/renderer_host/render_message_filter.h

@@ -106,6 +106,7 @@ class CONTENT_EXPORT RenderMessageFilter
                                     base::Time expected_response_time,
                                     const std::vector<uint8_t>& data) override;
   void FetchCachedCode(const GURL& url, FetchCachedCodeCallback) override;
+  void ClearCodeCacheEntry(const GURL& url) override;
   void DidGenerateCacheableMetadataInCacheStorage(
       const GURL& url,
       base::Time expected_response_time,

content/common/render_message_filter.mojom

@@ -37,6 +37,8 @@ interface RenderMessageFilter {
   FetchCachedCode(url.mojom.Url url) => (mojo_base.mojom.Time response_time,
                                          array<uint8> data);
 
+  ClearCodeCacheEntry(url.mojom.Url url);
+
   // Requests that the browser cache |data| for the specified CacheStorage entry.
   DidGenerateCacheableMetadataInCacheStorage(
       url.mojom.Url url, mojo_base.mojom.Time expected_response_time,

content/public/test/mock_render_thread.cc

@@ -77,6 +77,8 @@ class MockRenderMessageFilterImpl : public mojom::RenderMessageFilter {
     NOTREACHED();
   }
 
+  void ClearCodeCacheEntry(const GURL& url) override { NOTREACHED(); }
+
   void DidGenerateCacheableMetadataInCacheStorage(
       const GURL& url,
       base::Time expected_response_time,

content/renderer/renderer_blink_platform_impl.cc

@@ -467,6 +467,11 @@ void RendererBlinkPlatformImpl::FetchCachedCode(
       url, std::move(callback));
 }
 
+void RendererBlinkPlatformImpl::ClearCodeCacheEntry(const GURL& url) {
+  RenderThreadImpl::current()->render_message_filter()->ClearCodeCacheEntry(
+      url);
+}
+
 void RendererBlinkPlatformImpl::CacheMetadataInCacheStorage(
     const blink::WebURL& url,
     base::Time response_time,

content/renderer/renderer_blink_platform_impl.h

@@ -91,6 +91,7 @@ class CONTENT_EXPORT RendererBlinkPlatformImpl : public BlinkPlatformImpl {
       const blink::WebURL&,
       base::OnceCallback<void(base::Time, const std::vector<uint8_t>&)>)
       override;
+  void ClearCodeCacheEntry(const GURL&) override;
   void CacheMetadataInCacheStorage(
       const blink::WebURL&,
       base::Time,

third_party/blink/public/platform/platform.h

@@ -368,6 +368,7 @@ class BLINK_PLATFORM_EXPORT Platform {
   virtual void FetchCachedCode(
       const WebURL&,
       base::OnceCallback<void(base::Time, const std::vector<uint8_t>&)>) {}
+  virtual void ClearCodeCacheEntry(const GURL&) {}
 
   // A suggestion to cache this metadata in association with this URL which
   // resource is in CacheStorage.