Make the request initiator Optional

net/url_request/url_fetcher_core.cc

 // Copyright (c) 2012 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 "net/url_request/url_fetcher_core.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 13 matching lines @@
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/base/upload_file_element_reader.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/redirect_info.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_fetcher_response_writer.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_throttler_manager.h"
+#include "url/origin.h"
 
 namespace {
 
 const int kBufferSize = 4096;
 const int kUploadProgressTimerInterval = 100;
 bool g_ignore_certificate_requests = false;
 
 void EmptyCompletionCallback(int result) {}
 
 }  // namespace
@@ skipping 195 matching lines @@
   extra_request_headers_.AddHeaderFromString(header_line);
 }
 
 void URLFetcherCore::SetRequestContext(
     URLRequestContextGetter* request_context_getter) {
   DCHECK(!request_context_getter_.get());
   DCHECK(request_context_getter);
   request_context_getter_ = request_context_getter;
 }
 
-void URLFetcherCore::SetInitiatorURL(const GURL& initiator) {
-  DCHECK(initiator_.is_empty());
+void URLFetcherCore::SetInitiator(
+    const base::Optional<url::Origin>& initiator) {
+  DCHECK(!initiator_.has_value());
   initiator_ = initiator;
 }
 
 void URLFetcherCore::SetURLRequestUserData(
     const void* key,
     const URLFetcher::CreateDataCallback& create_data_callback) {
   DCHECK(key);
   DCHECK(!create_data_callback.is_null());
   url_request_data_key_ = key;
   url_request_create_data_callback_ = create_data_callback;
@@ skipping 291 matching lines @@
   int flags = request_->load_flags() | load_flags_;
 
   // TODO(mmenke): This should really be with the other code to set the upload
   // body, below.
   if (chunked_stream_)
     request_->set_upload(std::move(chunked_stream_));
 
   request_->SetLoadFlags(flags);
   request_->SetReferrer(referrer_);
   request_->set_referrer_policy(referrer_policy_);
-  request_->set_first_party_for_cookies(initiator_.is_empty() ? original_url_
-                                                              : initiator_);
-  request_->set_initiator(initiator_.is_empty() ? url::Origin(original_url_)
-                                                : url::Origin(initiator_));
+  request_->set_first_party_for_cookies(initiator_.has_value() &&
+                                                !initiator_.value().unique()
+                                            ? initiator_.value().GetURL()
+                                            : original_url_);
+  request_->set_initiator(initiator_);
   if (url_request_data_key_ && !url_request_create_data_callback_.is_null()) {
     request_->SetUserData(url_request_data_key_,
                           url_request_create_data_callback_.Run());
   }
 
   switch (request_type_) {
     case URLFetcher::GET:
       break;
 
     case URLFetcher::POST:
@@ skipping 116 matching lines @@
   // URLRequestJob::NotifyDone(). But, because the request was released
   // immediately after being canceled, the request could not call
   // OnReadCompleted() which overwrites |status_| with the error status.
   status_ = URLRequestStatus(URLRequestStatus::CANCELED, error);
 
   // Release the reference to the request context. There could be multiple
   // references to URLFetcher::Core at this point so it may take a while to
   // delete the object, but we cannot delay the destruction of the request
   // context.
   request_context_getter_ = NULL;
-  initiator_ = GURL();
+  initiator_.reset();
   url_request_data_key_ = NULL;
   url_request_create_data_callback_.Reset();
   was_cancelled_ = true;
 }
 
 void URLFetcherCore::OnCompletedURLRequest(
     base::TimeDelta backoff_delay) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
   // Save the status and backoff_delay so that delegates can read it.
@@ skipping 70 matching lines @@
     ++num_retries_on_network_changes_;
 
     // Retry soon, after flushing all the current tasks which may include
     // further network change observers.
     network_task_runner_->PostTask(
         FROM_HERE, base::Bind(&URLFetcherCore::StartOnIOThread, this));
     return;
   }
 
   request_context_getter_ = NULL;
-  initiator_ = GURL();
+  initiator_.reset();
   url_request_data_key_ = NULL;
   url_request_create_data_callback_.Reset();
   bool posted = delegate_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&URLFetcherCore::OnCompletedURLRequest, this, backoff_delay));
 
   // If the delegate message loop does not exist any more, then the delegate
   // should be gone too.
   DCHECK(posted || !delegate_);
 }
@@ skipping 145 matching lines @@
 }
 
 void URLFetcherCore::AssertHasNoUploadData() const {
   DCHECK(!upload_content_set_);
   DCHECK(upload_content_.empty());
   DCHECK(upload_file_path_.empty());
   DCHECK(upload_stream_factory_.is_null());
 }
 
 }  // namespace net