Add Client Attribute to FetchEvent- Chromium Side.

content/browser/cache_storage/cache_storage_cache.cc

 // Copyright 2014 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/cache_storage/cache_storage_cache.h"
 
 #include <string>
 
 #include "base/barrier_closure.h"
 #include "base/files/file_path.h"
@@ skipping 746 matching lines @@
 }
 
 void CacheStorageCache::Put(const CacheStorageBatchOperation& operation,
                             const ErrorCallback& callback) {
   DCHECK(BACKEND_OPEN == backend_state_ || initializing_);
   DCHECK_EQ(CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT, operation.operation_type);
 
   scoped_ptr<ServiceWorkerFetchRequest> request(new ServiceWorkerFetchRequest(
       operation.request.url, operation.request.method,
       operation.request.headers, operation.request.referrer,
-      operation.request.is_reload));
+      operation.request.is_reload, operation.request.client));
 
   // We don't support streaming for cache.
   DCHECK(operation.response.stream_url.is_empty());
   scoped_ptr<ServiceWorkerResponse> response(new ServiceWorkerResponse(
       operation.response.url, operation.response.status_code,
       operation.response.status_text, operation.response.response_type,
       operation.response.headers, operation.response.blob_uuid,
       operation.response.blob_size, operation.response.stream_url));
 
   scoped_ptr<storage::BlobDataHandle> blob_data_handle;
@@ skipping 194 matching lines @@
 
 void CacheStorageCache::Delete(const CacheStorageBatchOperation& operation,
                                const ErrorCallback& callback) {
   DCHECK(BACKEND_OPEN == backend_state_ || initializing_);
   DCHECK_EQ(CACHE_STORAGE_CACHE_OPERATION_TYPE_DELETE,
             operation.operation_type);
 
   scoped_ptr<ServiceWorkerFetchRequest> request(new ServiceWorkerFetchRequest(
       operation.request.url, operation.request.method,
       operation.request.headers, operation.request.referrer,
-      operation.request.is_reload));
+      operation.request.is_reload, operation.request.client));
 
   ErrorCallback pending_callback =
       base::Bind(&CacheStorageCache::PendingErrorCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
   scheduler_->ScheduleOperation(
       base::Bind(&CacheStorageCache::DeleteImpl, weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(request.Pass()), pending_callback));
 }
 
 void CacheStorageCache::DeleteImpl(
@@ skipping 138 matching lines @@
 
 void CacheStorageCache::KeysDidReadMetadata(
     scoped_ptr<KeysContext> keys_context,
     const Entries::iterator& iter,
     scoped_ptr<CacheMetadata> metadata) {
   disk_cache::Entry* entry = *iter;
 
   if (metadata) {
     keys_context->out_keys->push_back(ServiceWorkerFetchRequest(
         GURL(entry->GetKey()), metadata->request().method(),
-        ServiceWorkerHeaderMap(), Referrer(), false));
+        ServiceWorkerHeaderMap(), Referrer(), false,
+        ServiceWorkerClientInfo()));
 
     ServiceWorkerHeaderMap& req_headers =
         keys_context->out_keys->back().headers;
 
     for (int i = 0; i < metadata->request().headers_size(); ++i) {
       const CacheHeaderMap header = metadata->request().headers(i);
       DCHECK(header.name().find('\0') == std::string::npos);
       DCHECK(header.value().find('\0') == std::string::npos);
       req_headers.insert(std::make_pair(header.name(), header.value()));
     }
@@ skipping 114 matching lines @@
     CacheStorageError error,
     scoped_ptr<Requests> requests) {
   base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
 
   callback.Run(error, requests.Pass());
   if (cache)
     scheduler_->CompleteOperationAndRunNext();
 }
 
 }  // namespace content