Store Origin-Trial tokens to ServiceWorkerDataBase

content/browser/service_worker/service_worker_version.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/browser/service_worker/service_worker_version.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
@@ skipping 16 matching lines @@
 #include "content/browser/message_port_message_filter.h"
 #include "content/browser/message_port_service.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/embedded_worker_status.h"
 #include "content/browser/service_worker/service_worker_client_utils.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/browser/service_worker/service_worker_registration.h"
+#include "content/common/origin_trials/trial_token_validator.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
 #include "content/common/service_worker/embedded_worker_start_params.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/common/service_worker/service_worker_type_converters.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "mojo/common/common_type_converters.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
+#include "third_party/WebKit/public/platform/WebOriginTrialTokenStatus.h"
 
 namespace content {
 
 using StatusCallback = ServiceWorkerVersion::StatusCallback;
 
 namespace {
 
 // Time to wait until stopping an idle worker.
 const int kIdleWorkerTimeoutSeconds = 30;
 
@@ skipping 632 matching lines @@
     else
       embedded_worker_->Stop();
   }
   if (!context_)
     return;
   std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
   script_cache_map_.GetResources(&resources);
   context_->storage()->PurgeResources(resources);
 }
 
+void ServiceWorkerVersion::SetValidOriginTrialTokens(
+    const TrialTokenValidator::FeatureToTokensMap& tokens) {
+  origin_trial_tokens_ =
+      base::MakeUnique<TrialTokenValidator::FeatureToTokensMap>();
+  for (const auto& feature : tokens) {
+    for (const std::string& token : feature.second) {
+      std::string feature_name;
+      if (TrialTokenValidator::ValidateToken(token, url::Origin(scope()),

[chasej, 2016/10/05 23:39:54]

ValidateToken() does not currently check if the entire origin trials framework
is enabled. See TrialTokenValidator::RequestEnablesFeature().  With this code,
it's possible that previously saved tokens will be reported as still valid, even
though the framework is now disabled.

It might make sense for ValidateToken() to have the check for the framework
being enabled. That method was originally written assuming a caller that already
checked for framework enablement.

Alternatively, maybe this method should be encapsulated as
TrialTokenValidator::SetValidTokens(in, out).

All of the above also applies to the check for secure origins, which are
required for origin trials. Service workers already require secure origins, but
a later caller may not have that constraint.

[horo, 2016/10/06 06:59:25]

Done.

+                                             &feature_name) ==
+          blink::WebOriginTrialTokenStatus::Success) {
+        (*origin_trial_tokens_)[feature.first].push_back(token);
+      }
+    }
+  }
+}
+
 void ServiceWorkerVersion::SetDevToolsAttached(bool attached) {
   embedded_worker()->set_devtools_attached(attached);
   if (stop_when_devtools_detached_ && !attached) {
     DCHECK_EQ(REDUNDANT, status());
     if (running_status() == EmbeddedWorkerStatus::STARTING ||
         running_status() == EmbeddedWorkerStatus::RUNNING) {
       embedded_worker_->Stop();
     }
     return;
   }
@@ skipping 21 matching lines @@
 
   // Reactivate request timeouts, setting them all to the same expiration time.
   SetAllRequestExpirations(
       base::TimeTicks::Now() +
       base::TimeDelta::FromMinutes(kRequestTimeoutMinutes));
 }
 
 void ServiceWorkerVersion::SetMainScriptHttpResponseInfo(
     const net::HttpResponseInfo& http_info) {
   main_script_http_info_.reset(new net::HttpResponseInfo(http_info));
+
+  // Updates |origin_trial_tokens_| if it is not set yet. This happens when:
+  //  1) The worer is a new one.
+  //  OR
+  //  2) The worker is an existing one but the entry in ServiceWorkerDatabase
+  //     was written by old version Chrome, so |origin_trial_tokens| wasn't set
+  //     in the entry.
+  if (!origin_trial_tokens_) {
+    origin_trial_tokens_ = TrialTokenValidator::GetValidTokens(
+        url::Origin(scope()), http_info.headers.get());
+  }
+
   FOR_EACH_OBSERVER(Listener, listeners_,
                     OnMainScriptHttpResponseInfoSet(this));
 }
 
 void ServiceWorkerVersion::SimulatePingTimeoutForTesting() {
   ping_controller_->SimulateTimeoutForTesting();
 }
 
 const net::HttpResponseInfo*
 ServiceWorkerVersion::GetMainScriptHttpResponseInfo() {
@@ skipping 1041 matching lines @@
   ServiceWorkerMetrics::RecordTimeBetweenEvents(base::TimeTicks::Now() -
                                                 idle_time_);
 }
 
 void ServiceWorkerVersion::FinishStartWorker(ServiceWorkerStatusCode status) {
   start_worker_first_purpose_ = base::nullopt;
   RunCallbacks(this, &start_callbacks_, status);
 }
 
 }  // namespace content