#include "atom/browser/api/save_page_handler.h"
#include "atom/browser/atom_browser_context.h"
#include "atom/browser/atom_browser_main_parts.h"
-#include "atom/browser/browser.h"
#include "atom/common/native_mate_converters/callback.h"
#include "atom/common/native_mate_converters/gurl_converter.h"
#include "atom/common/native_mate_converters/file_path_converter.h"
Session::Session(AtomBrowserContext* browser_context)
: browser_context_(browser_context) {
AttachAsUserData(browser_context);
-
- // Observe Browser to get certificate verification notification.
- Browser::Get()->AddObserver(this);
+ browser_context->cert_verifier()->SetDelegate(this);
// Observe DownloadManger to get download notifications.
content::BrowserContext::GetDownloadManager(browser_context)->
Session::~Session() {
content::BrowserContext::GetDownloadManager(browser_context())->
RemoveObserver(this);
- Browser::Get()->RemoveObserver(this);
Destroy();
}
-void Session::OnCertVerification(
+void Session::RequestCertVerification(
const scoped_refptr<AtomCertVerifier::CertVerifyRequest>& request) {
bool prevent_default = Emit(
"verify-certificate",
#include "atom/browser/api/trackable_object.h"
#include "atom/browser/atom_cert_verifier.h"
-#include "atom/browser/browser_observer.h"
#include "content/public/browser/download_manager.h"
#include "native_mate/handle.h"
#include "net/base/completion_callback.h"
namespace api {
class Session: public mate::TrackableObject<Session>,
- public BrowserObserver,
+ public AtomCertVerifier::Delegate,
public content::DownloadManager::Observer {
public:
using ResolveProxyCallback = base::Callback<void(std::string)>;
explicit Session(AtomBrowserContext* browser_context);
~Session();
- // BrowserObserver:
- void OnCertVerification(
+ // AtomCertVerifier::Delegate:
+ void RequestCertVerification(
const scoped_refptr<AtomCertVerifier::CertVerifyRequest>&) override;
// content::DownloadManager::Observer:
AtomBrowserContext::AtomBrowserContext(const std::string& partition,
bool in_memory)
: brightray::BrowserContext(partition, in_memory),
+ cert_verifier_(new AtomCertVerifier),
job_factory_(new AtomURLRequestJobFactory),
allow_ntlm_everywhere_(false) {
}
}
net::CertVerifier* AtomBrowserContext::CreateCertVerifier() {
- return new AtomCertVerifier;
+ return cert_verifier_;
}
net::SSLConfigService* AtomBrowserContext::CreateSSLConfigService() {
namespace atom {
class AtomDownloadManagerDelegate;
+class AtomCertVerifier;
class AtomURLRequestJobFactory;
class WebViewManager;
void AllowNTLMCredentialsForAllDomains(bool should_allow);
+ AtomCertVerifier* cert_verifier() const { return cert_verifier_; }
+
AtomURLRequestJobFactory* job_factory() const { return job_factory_; }
private:
scoped_ptr<WebViewManager> guest_manager_;
// Managed by brightray::BrowserContext.
+ AtomCertVerifier* cert_verifier_;
AtomURLRequestJobFactory* job_factory_;
bool allow_ntlm_everywhere_;
#include "atom/browser/browser.h"
#include "atom/common/native_mate_converters/net_converter.h"
-#include "base/callback_helpers.h"
#include "base/sha1.h"
#include "base/stl_util.h"
#include "content/public/browser/browser_thread.h"
for (auto& callback : callbacks_)
callback.Run(result);
cert_verifier_->RemoveRequest(this);
- Release();
}
void AtomCertVerifier::CertVerifyRequest::DelegateToDefaultVerifier() {
verify_result_,
base::Bind(&CertVerifyRequest::RunResult,
weak_ptr_factory_.GetWeakPtr()),
- &new_out_req_,
+ out_req_,
net_log_);
- if (rv != net::ERR_IO_PENDING && !callbacks_.empty()) {
- for (auto& callback : callbacks_)
- callback.Run(rv);
- cert_verifier_->RemoveRequest(this);
- Release();
- }
+ if (rv != net::ERR_IO_PENDING)
+ RunResult(rv);
}
void AtomCertVerifier::CertVerifyRequest::ContinueWithResult(int result) {
weak_ptr_factory_.GetWeakPtr()));
}
-AtomCertVerifier::AtomCertVerifier() {
+AtomCertVerifier::AtomCertVerifier()
+ : delegate_(nullptr) {
default_cert_verifier_.reset(net::CertVerifier::CreateDefault());
}
const net::BoundNetLog& net_log) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
- if (callback.is_null() || !verify_result || hostname.empty())
+ if (callback.is_null() || !verify_result || hostname.empty() || !delegate_)
return net::ERR_INVALID_ARGUMENT;
const RequestParams key(cert->fingerprint(),
requests_.insert(make_scoped_refptr(request));
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
- base::Bind(&Browser::RequestCertVerification,
- base::Unretained(Browser::Get()),
+ base::Bind(&Delegate::RequestCertVerification,
+ base::Unretained(delegate_),
make_scoped_refptr(request)));
}
};
class CertVerifyRequest
- : public net::CertVerifier::Request,
- public base::RefCountedThreadSafe<CertVerifyRequest> {
+ : public base::RefCountedThreadSafe<CertVerifyRequest> {
public:
CertVerifyRequest(
AtomCertVerifier* cert_verifier,
net_log_(net_log),
handled_(false),
weak_ptr_factory_(this) {
- out_req_->reset(this);
- new_out_req_.reset(new net::CertVerifier::Request());
- }
-
- ~CertVerifyRequest() {
- out_req_->reset();
}
void RunResult(int result);
private:
friend class base::RefCountedThreadSafe<CertVerifyRequest>;
+ ~CertVerifyRequest() {}
AtomCertVerifier* cert_verifier_;
const RequestParams key_;
scoped_refptr<net::CRLSet> crl_set_;
net::CertVerifyResult* verify_result_;
scoped_ptr<Request>* out_req_;
- scoped_ptr<Request> new_out_req_;
const net::BoundNetLog net_log_;
std::vector<net::CompletionCallback> callbacks_;
DISALLOW_COPY_AND_ASSIGN(CertVerifyRequest);
};
+ class Delegate {
+ public:
+ Delegate() {}
+ virtual ~Delegate() {}
+
+ // Called on UI thread.
+ virtual void RequestCertVerification(
+ const scoped_refptr<CertVerifyRequest>& request) {}
+ };
+
AtomCertVerifier();
- ~AtomCertVerifier() override;
+ virtual ~AtomCertVerifier();
+
+ void SetDelegate(Delegate* delegate) {
+ delegate_ = delegate;
+ }
protected:
// net::CertVerifier:
CertVerifyRequestComparator>;
ActiveRequestSet requests_;
+ Delegate* delegate_;
+
scoped_ptr<net::CertVerifier> default_cert_verifier_;
DISALLOW_COPY_AND_ASSIGN(AtomCertVerifier);
#include <string>
#include "atom/browser/atom_browser_main_parts.h"
-#include "atom/browser/atom_cert_verifier.h"
#include "atom/browser/native_window.h"
#include "atom/browser/window_list.h"
#include "base/message_loop/message_loop.h"
FOR_EACH_OBSERVER(BrowserObserver, observers_, OnLogin(login_handler));
}
-void Browser::RequestCertVerification(
- const scoped_refptr<AtomCertVerifier::CertVerifyRequest>& request) {
- FOR_EACH_OBSERVER(BrowserObserver,
- observers_,
- OnCertVerification(request));
-}
-
void Browser::NotifyAndShutdown() {
if (is_shutdown_)
return;
namespace atom {
-class AtomCertVerifier;
class LoginHandler;
// This class is used for control application-wide operations.
// Request basic auth login.
void RequestLogin(LoginHandler* login_handler);
- // Request Server Certificate Verification.
- void RequestCertVerification(
- const scoped_refptr<AtomCertVerifier::CertVerifyRequest>& request);
-
void AddObserver(BrowserObserver* obs) {
observers_.AddObserver(obs);
}
#include <string>
-#include "atom/browser/atom_cert_verifier.h"
#include "base/memory/scoped_ptr.h"
#include "content/public/browser/client_certificate_delegate.h"
namespace net {
class SSLCertRequestInfo;
-class X509Certificate;
}
namespace atom {
// The browser requests HTTP login.
virtual void OnLogin(LoginHandler* login_handler) {}
- // The browser requests Server Certificate Verification.
- virtual void OnCertVerification(
- const scoped_refptr<AtomCertVerifier::CertVerifyRequest>& request) {}
-
protected:
virtual ~BrowserObserver() {}
};