blob: bb4509a9ac4133ed2523eea0cc37f267449250e7 [file] [log] [blame]
// 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.
#import <Foundation/Foundation.h>
#include <stdint.h>
#include <map>
#include <set>
#include "base/callback_forward.h"
#include "base/mac/scoped_nsobject.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_vector.h"
#include "base/memory/weak_ptr.h"
#import "ios/net/request_tracker.h"
#import "ios/web/net/crw_request_tracker_delegate.h"
#include "ios/web/public/web_thread.h"
#include "net/url_request/url_request_context_getter.h"
#include "url/gurl.h"
@class SSLCarrier;
@class CRWSSLCarrier;
struct TrackerCounts;
namespace content {
struct SSLStatus;
namespace net {
class HttpResponseHeaders;
class URLRequest;
class URLRequestContext;
class SSLInfo;
class X509Certificate;
namespace web {
class BrowserState;
class CertificatePolicyCache;
// Structure to capture the current state of a page.
struct PageCounts {
PageCounts() : finished(0),
largest_byte_size_known(0) {
// Count of finished requests.
uint64_t finished;
// Total bytes count dowloaded for all finished requests.
uint64_t finished_bytes;
// Count of unfinished requests.
uint64_t unfinished;
// Count of unfinished requests with unknown size.
uint64_t unfinished_no_estimate;
// Total bytes count dowloaded for unfinished requests of unknown size.
uint64_t unfinished_no_estimate_bytes_done;
// Count of unfinished requests with an estimated size.
uint64_t unfinished_estimated_bytes_left;
// Total bytes count dowloaded for unfinished requests with an estimated size.
uint64_t unfinished_estimate_bytes_done;
// Size of the request with the most bytes on the page.
uint64_t largest_byte_size_known;
// RequestTrackerImpl captures and stores all the network requests that
// initiated from a particular tab. It only keeps the URLs and eventually, if
// available, the expected length of the result and the length of the received
// data so far as this is used to build a progress bar for a page.
// Note that the Request tracker has no notion of a page, it only tracks the
// requests by tab. In order for the tracker to know that a request is for a
// page or a subresource it is necessary for the tab to call StartPageLoad()
// with the URL of the page once it is known to avoid storing all the requests
// forever.
// The consumer needs to implement the CRWRequestTrackerImplDelegate protocol
// and needs to call StartPageLoad() and FinishPageLoad() to indicate the page
// boundaries. StartPageLoad() will also have the side effect of clearing past
// requests from memory. The consumer is assumed to be on the UI thread at all
// times.
// RequestTrackerImpl objects are created and destroyed on the UI thread and
// must be owned by some other object on the UI thread by way of a
// scoped_refptr, as returned by the public static constructor method,
// CreateTrackerForRequestGroupID. All consumer API methods will be called
// through this pointer.
class RequestTrackerImpl;
struct RequestTrackerImplTraits {
static void Destruct(const RequestTrackerImpl* t);
class RequestTrackerImpl
: public base::RefCountedThreadSafe<RequestTrackerImpl,
public net::RequestTracker {
#pragma mark Public Consumer API
// Consumer API methods should only be called on the UI thread.
// Create a new RequestTrackerImpl associated with a particular tab. The
// profile must be the one associated to the given tab. This method has to be
// called *once* per tab and needs to be called before triggering any network
// request. The caller of CreateTrackerForRequestGroupID owns the tracker, and
// this class also keeps a global map of all active trackers. When the owning
// object releases it, the class removes it from the global map.
static scoped_refptr<RequestTrackerImpl> CreateTrackerForRequestGroupID(
NSString* request_group_id,
BrowserState* browser_state,
net::URLRequestContextGetter* context_getter,
id<CRWRequestTrackerDelegate> delegate);
// The network layer has no way to know which network request is the primary
// one for a page load. The tab knows, either because it initiated the page
// load via the URL or received a callback informing it of the page change.
// Every time this happens the tab should call this method to clear the
// resources tracked.
// This will forget all the finished requests made before this URL in history.
// user_info is to be used by the consumer to store more additional specific
// info about the page, as an URL is not unique.
void StartPageLoad(const GURL& url, id user_info);
// In order to properly provide progress information the tracker needs to know
// when the page is fully loaded. |load_success| indicates if the page
// successfully loaded.
void FinishPageLoad(const GURL& url, bool load_success);
// Tells the tracker that history.pushState() or history.replaceState()
// changed the page URL.
void HistoryStateChange(const GURL& url);
// Marks the tracker as closed. An owner must call this before the tracker is
// deleted. Once closed, no further calls will be made to the delegate.
void Close();
// Call |callback| on the UI thread after any pending request cancellations
// have completed on the IO thread.
// This should be used to delete a profile for which all of the trackers
// that use the profile's request context are closed.
static void RunAfterRequestsCancel(const base::Closure& callback);
// Block until all pending IO thread activity has completed. This should only
// be used when Chrome is shutting down, and after all request trackers have
// had Close() called on them.
static void BlockUntilTrackersShutdown();
#pragma mark Client utility methods.
// Finds the tracker given the tab ID. As calling this method involves a lock
// it is expected that the provider will call it only once.
// Returns a weak pointer, which should only be dereferenced on the IO thread.
// Returns NULL if no tracker exists for |request_group_id|.
static RequestTrackerImpl* GetTrackerForRequestGroupID(
NSString* request_group_id);
// Callback from the UI to allow or deny a particular certificate.
void ErrorCallback(CRWSSLCarrier* carrier, bool allow);
// Utility method for clients to post tasks to the IO thread from the UI
// thread.
void PostIOTask(const base::Closure& task);
// Utility method for clients to post tasks to the IO thread from the IO
// thread.
void ScheduleIOTask(const base::Closure& task);
// Utility method for clients to conditionally post tasks to the UI thread
// from the IO thread. The task will not be posted if the request tracker
// is in the process of closing (thus it "is open").
void PostUITaskIfOpen(const base::Closure& task);
// Static version of the method, where |tracker| is a RequestTrackerImpl
// passed as a base::WeakPtr<RequestTracker>.
static void PostUITaskIfOpen(const base::WeakPtr<RequestTracker> tracker,
const base::Closure& task);
// Sets the cache mode. Must be called from the UI thread.
void SetCacheModeFromUIThread(RequestTracker::CacheMode mode);
#pragma mark Testing methods
void SetCertificatePolicyCacheForTest(web::CertificatePolicyCache* cache);
#pragma mark Accessors used by internal classes and network clients.
int identifier() { return identifier_; }
bool has_mixed_content() { return has_mixed_content_; }
// RequestTracker implementation.
void StartRequest(net::URLRequest* request) override;
void CaptureHeaders(net::URLRequest* request) override;
void CaptureExpectedLength(const net::URLRequest* request,
uint64_t length) override;
void CaptureReceivedBytes(const net::URLRequest* request,
uint64_t byte_count) override;
void CaptureCertificatePolicyCache(
const net::URLRequest* request,
const SSLCallback& should_continue) override;
void StopRequest(net::URLRequest* request) override;
void StopRedirectedRequest(net::URLRequest* request) override;
void OnSSLCertificateError(const net::URLRequest* request,
const net::SSLInfo& ssl_info,
bool recoverable,
const SSLCallback& should_continue) override;
net::URLRequestContext* GetRequestContext() override;
friend class base::RefCountedThreadSafe<RequestTrackerImpl>;
friend struct RequestTrackerImplTraits;
#pragma mark Object lifecycle API
// Private. RequestTrackerImpls are created through
// CreateTrackerForRequestGroupID().
RequestTrackerImpl(NSString* request_group_id,
net::URLRequestContextGetter* context_getter,
id<CRWRequestTrackerDelegate> delegate);
void InitOnIOThread(
const scoped_refptr<web::CertificatePolicyCache>& policy_cache);
// Private destructor because the object is reference counted. A no-op; the
// useful destruction work happens in Destruct().
~RequestTrackerImpl() override;
// Handles pre-destruction destruction tasks. This is invoked by
// RequestTrackerImplTraits::Destruct whenever the reference count of a
// RequestTrackerImpl is zero, and this will untimately delete the
// RequestTrackerImpl.
void Destruct();
#pragma mark Private Provider API
// Private methods that implement provider API features. All are only called
// on the IO thread.
// Called when something has changed (network load progress or SSL status)
// that the consumer should know about. Notifications are asynchronous and
// batched.
void Notify();
// If no other notifications are pending, notifies the consumer of SSL status
// and load progress.
void StackNotification();
// Notify the consumer about the SSL status of this tracker's page load.
void SSLNotify();
// If the counts is for a request currently waiting for the user to approve it
// will reevaluate the approval.
void EvaluateSSLCallbackForCounts(TrackerCounts* counts);
// Loop through all the requests waiting for approval and invoke
// |-evaluateSSLCallbackForCounts:| on all the ones with an |UNKNOWN|
// judgment.
void ReevaluateCallbacksForAllCounts();
// To cancel a rejected request due to a SSL issue.
void CancelRequestForCounts(TrackerCounts* counts);
// Estimate the page load progress. Returns -1 if the progress didn't change
// since the last time this method was invoked.
float EstimatedProgress();
// The URL change notification is often late, therefore the mixed content
// status and the certificate policies may need to be recomputed.
void RecomputeMixedContent(const TrackerCounts* split_position);
void RecomputeCertificatePolicy(const TrackerCounts* split_position);
// Remove all finished request up to the last instance of |url|. If url is not
// found, this will clear all the requests.
void TrimToURL(const GURL& url, id user_info);
// Sets page_url_ to the new URL if it's a valid history state change (i.e.
// the URL's have the same origin) and if the tab is currently loading.
void HistoryStateChangeToURL(const GURL& full_url);
// Note that the page started by a call to Trim is no longer loading.
// |load_success| indicates if the page successfully loaded.
void StopPageLoad(const GURL& url, bool load_success);
// Cancels all the requests in |live_requests_|.
void CancelRequests();
#pragma mark Private Consumer API
// Private methods that call into delegate methods.
// Notify* methods are posted to the UI thread by the provider API
// methods.
// Has the delegate handle |headers| for |request_url|.
void NotifyResponseHeaders(net::HttpResponseHeaders* headers,
const GURL& request_url);
// Notifies the deleage of certificate use.
void NotifyCertificateUsed(net::X509Certificate* certificate,
const std::string& host,
net::CertStatus status);
// Notifies the deleate of a load completion estimate.
void NotifyUpdatedProgress(float estimate);
// Has the delegate clear SSL certificates.
void NotifyClearCertificates();
// Notifies the delegate of an SSL status update.
void NotifyUpdatedSSLStatus(base::scoped_nsobject<CRWSSLCarrier> carrier);
// Calls the delegate method to present an SSL error interstitial.
void NotifyPresentSSLError(base::scoped_nsobject<CRWSSLCarrier> carrier,
bool recoverable);
#pragma mark Internal utilities for task posting
// Posts |task| to |thread|. Must not be called from |thread|. If |thread| is
// the IO thread, silently returns if |is_closing_| is true.
void PostTask(const base::Closure& task, web::WebThread::ID thread);
// Posts |block| to |thread|, safely passing in |caller| to |block|.
void PostBlock(id caller, void (^block)(id), web::WebThread::ID thread);
#pragma mark Other internal methods.
// Returns the current state of the page.
PageCounts pageCounts();
// Like description, but cannot be called from any thread. It must be called
// only from the IO thread.
NSString* UnsafeDescription();
// Generates a string unique to this RequestTrackerImpl to use with the
// CRWNetworkActivityIndicatorManager.
NSString* GetNetworkActivityKey();
#pragma mark Non thread-safe fields, only accessed from the main thread.
// The RequestTrackerImpl delegate. All changes and access to this object
// should be done on the main thread.
id<CRWRequestTrackerDelegate> delegate_; // Weak.
#pragma mark Non thread-safe fields, only accessed from the IO thread.
// All the tracked requests for the page, indexed by net::URLRequest (Cast as
// a void* to avoid the temptation of accessing it from the wrong thread).
// This map is not exhaustive: it is only meant to estimate the loading
// progress, and thus requests corresponding to old navigation events are not
// in it.
std::map<const void*, TrackerCounts*> counts_by_request_;
// All the live requests associated with the tracker.
std::set<net::URLRequest*> live_requests_;
// A list of all the TrackerCounts, including the finished ones.
ScopedVector<TrackerCounts> counts_;
// The system shall never allow the page load estimate to go back.
float previous_estimate_;
// Index of the first request to consider for building the estimation.
unsigned int estimate_start_index_;
// How many notifications are currently queued, to avoid notifying too often.
int notification_depth_;
// The tracker containing the error currently presented to the user.
TrackerCounts* current_ssl_error_;
// Set to |YES| if the page has mixed content
bool has_mixed_content_;
// Set to true if between TrimToURL and StopPageLoad.
bool is_loading_;
// Set to true in TrimToURL if starting a new estimate round. Set to false by
// StartRequest once the new round is started.
bool new_estimate_round_;
#pragma mark Other fields.
scoped_refptr<web::CertificatePolicyCache> policy_cache_;
// If |true| all the requests should be static file requests, otherwise all
// the requests should be network requests. This is a constant initialized
// in the constructor and read in IO and UI threads.
const bool is_for_static_file_requests_;
scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
// Current page URL, as far as we know.
GURL page_url_;
// Userinfo attached to the page, passed back by the delegate.
base::scoped_nsobject<id> user_info_;
// A tracker identifier (a simple increasing number) used to store
// certificates.
int identifier_;
// The string that identifies the tab this tracker serves. Used to index
// g_trackers.
base::scoped_nsobject<NSString> request_group_id_;
// Flag to synchronize deletion and callback creation. Lives on the IO thread.
// True when this tracker has beed Close()d. If this is the case, no further
// references to it should be generated (for example by binding it into a
// callback), and the expectation is that it will soon be deleted.
bool is_closing_;
} // namespace web