Partially implement WorkerFetchContext and WorkerThreadableLoadingContext and add virtual tests

third_party/WebKit/Source/platform/loader/fetch/Resource.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
     rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
@@ skipping 251 matching lines @@
       type_(type),
       status_(ResourceStatus::kNotStarted),
       needs_synchronous_cache_hit_(false),
       link_preload_(false),
       is_revalidating_(false),
       is_alive_(false),
       is_add_remove_client_prohibited_(false),
       integrity_disposition_(ResourceIntegrityDisposition::kNotChecked),
       options_(options),
       response_timestamp_(CurrentTime()),
-      cancel_timer_(Platform::Current()->MainThread()->GetWebTaskRunner(),
+      cancel_timer_(IsMainThread()
+                        ? Platform::Current()->MainThread()->GetWebTaskRunner()
+                        : Platform::Current()
+                              ->CurrentThread()
+                              ->Scheduler()
+                              ->LoadingTaskRunner(),

[kinuko, 2017/05/12 08:41:45]

It feels slightly weird why we don't use loading task runner for main thread
cases..

[horo, 2017/05/12 09:06:02]

I think so too...
But I don't want to change the existing behavior in this CL.

[kinuko, 2017/05/13 05:54:55]

Yep, ok to leave it as is in this CL.

+yhirano@: do you know why this is using default task runner?

[yhirano, 2017/05/15 01:43:26]

No.

I also think this should be the loading task runner gotten from FetchContext,
though it's not accessible here.

                     this,
                     &Resource::CancelTimerFired),
       resource_request_(request) {
   InstanceCounters::IncrementCounter(InstanceCounters::kResourceCounter);
 
   // Currently we support the metadata caching only for HTTP family.
   if (GetResourceRequest().Url().ProtocolIsInHTTPFamily())
     cache_handler_ = CachedMetadataHandlerImpl::Create(this);
-  MemoryCoordinator::Instance().RegisterClient(this);
+  if (IsMainThread())
+    MemoryCoordinator::Instance().RegisterClient(this);
 }
 
 Resource::~Resource() {
   InstanceCounters::DecrementCounter(InstanceCounters::kResourceCounter);
 }
 
 DEFINE_TRACE(Resource) {
   visitor->Trace(loader_);
   visitor->Trace(cache_handler_);
   visitor->Trace(clients_);
@@ skipping 58 matching lines @@
   options_.data_buffering_policy = data_buffering_policy;
   ClearData();
   SetEncodedSize(0);
 }
 
 void Resource::FinishAsError(const ResourceError& error) {
   DCHECK(!error.IsNull());
   error_ = error;
   is_revalidating_ = false;
 
-  if (error_.IsCancellation() || !IsPreloaded())
+  if ((error_.IsCancellation() || !IsPreloaded()) && IsMainThread())
     GetMemoryCache()->Remove(this);
 
   if (!ErrorOccurred())
     SetStatus(ResourceStatus::kLoadError);
   DCHECK(ErrorOccurred());
   ClearData();
   loader_ = nullptr;
   CheckNotify();
 }
 
@@ skipping 208 matching lines @@
       builder.Append(' ');
     builder.Append("loader_");
   }
   if (preload_count_) {
     if (!builder.IsEmpty())
       builder.Append(' ');
     builder.Append("preload_count_(");
     builder.AppendNumber(preload_count_);
     builder.Append(')');
   }
-  if (GetMemoryCache()->Contains(this)) {
+  if (IsMainThread() && GetMemoryCache()->Contains(this)) {
     if (!builder.IsEmpty())
       builder.Append(' ');
     builder.Append("in_memory_cache");
   }
   return builder.ToString();
 }
 
 void Resource::DidAddClient(ResourceClient* c) {
   if (IsLoaded()) {
     c->NotifyFinished(this);
@@ skipping 105 matching lines @@
     is_alive_ = false;
     AllClientsAndObserversRemoved();
 
     // RFC2616 14.9.2:
     // "no-store: ... MUST make a best-effort attempt to remove the information
     // from volatile storage as promptly as possible"
     // "... History buffers MAY store such responses as part of their normal
     // operation."
     // We allow non-secure content to be reused in history, but we do not allow
     // secure content to be reused.
-    if (HasCacheControlNoStoreHeader() && Url().ProtocolIs("https"))
+    if (HasCacheControlNoStoreHeader() && Url().ProtocolIs("https") &&
+        IsMainThread())
       GetMemoryCache()->Remove(this);
   }
 }
 
 void Resource::AllClientsAndObserversRemoved() {
   if (!loader_)
     return;
   if (!cancel_timer_.IsActive())
     cancel_timer_.StartOneShot(0, BLINK_FROM_HERE);
 }
 
 void Resource::CancelTimerFired(TimerBase* timer) {
   DCHECK_EQ(timer, &cancel_timer_);
   if (!HasClientsOrObservers() && loader_)
     loader_->Cancel();
 }
 
 void Resource::SetDecodedSize(size_t decoded_size) {
   if (decoded_size == decoded_size_)
     return;
   size_t old_size = size();
   decoded_size_ = decoded_size;
-  GetMemoryCache()->Update(this, old_size, size());
+  if (IsMainThread())
+    GetMemoryCache()->Update(this, old_size, size());
 }
 
 void Resource::SetEncodedSize(size_t encoded_size) {
   if (encoded_size == encoded_size_ &&
       encoded_size == encoded_size_memory_usage_)
     return;
   size_t old_size = size();
   encoded_size_ = encoded_size;
   encoded_size_memory_usage_ = encoded_size;
-  GetMemoryCache()->Update(this, old_size, size());
+  if (IsMainThread())
+    GetMemoryCache()->Update(this, old_size, size());
 }
 
 void Resource::FinishPendingClients() {
   // We're going to notify clients one by one. It is simple if the client does
   // nothing. However there are a couple other things that can happen.
   //
   // 1. Clients can be added during the loop. Make sure they are not processed.
   // 2. Clients can be removed during the loop. Make sure they are always
   //    available to be removed. Also don't call removed clients or add them
   //    back.
@@ skipping 311 matching lines @@
     case Resource::kMedia:
     case Resource::kManifest:
     case Resource::kMock:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace blink