diff options
Diffstat (limited to 'chrome/browser/automation/automation_profile_impl.cc')
| -rw-r--r-- | chrome/browser/automation/automation_profile_impl.cc | 216 |
1 files changed, 216 insertions, 0 deletions
diff --git a/chrome/browser/automation/automation_profile_impl.cc b/chrome/browser/automation/automation_profile_impl.cc new file mode 100644 index 0000000..751019a --- /dev/null +++ b/chrome/browser/automation/automation_profile_impl.cc @@ -0,0 +1,216 @@ +// Copyright (c) 2006-2009 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 "chrome/browser/automation/automation_profile_impl.h" + +#include <map> + +#include "chrome/browser/automation/automation_resource_message_filter.h" +#include "chrome/browser/chrome_thread.h" +#include "chrome/browser/net/chrome_url_request_context.h" +#include "chrome/browser/profile.h" +#include "net/base/net_errors.h" +#include "net/url_request/url_request_context.h" +#include "chrome/test/automation/automation_messages.h" + +namespace AutomationRequestContext { + +// A special Request context for automation. Substitute a few things +// like cookie store, proxy settings etc to handle them differently +// for automation. +class AutomationURLRequestContext : public ChromeURLRequestContext { + public: + AutomationURLRequestContext(ChromeURLRequestContext* original_context, + net::CookieStore* automation_cookie_store, + net::CookiePolicy* automation_cookie_policy) + : ChromeURLRequestContext(original_context), + // We must hold a reference to |original_context|, since many + // of the dependencies that ChromeURLRequestContext(original_context) + // copied are scoped to |original_context|. + original_context_(original_context) { + cookie_policy_ = automation_cookie_policy; + cookie_store_ = automation_cookie_store; + } + + virtual bool IsExternal() const { + return true; + } + + private: + virtual ~AutomationURLRequestContext() { + // Clear out members before calling base class dtor since we don't + // own any of them. + + // Clear URLRequestContext members. + host_resolver_ = NULL; + proxy_service_ = NULL; + http_transaction_factory_ = NULL; + ftp_transaction_factory_ = NULL; + cookie_store_ = NULL; + transport_security_state_ = NULL; + } + + scoped_refptr<ChromeURLRequestContext> original_context_; + DISALLOW_COPY_AND_ASSIGN(AutomationURLRequestContext); +}; + +// CookieStore specialization to have automation specific +// behavior for cookies. +class AutomationCookieStore : public net::CookieStore { + public: + AutomationCookieStore(net::CookieStore* original_cookie_store, + AutomationResourceMessageFilter* automation_client, + int tab_handle) + : original_cookie_store_(original_cookie_store), + automation_client_(automation_client), + tab_handle_(tab_handle) { + } + + virtual ~AutomationCookieStore() { + DLOG(INFO) << "In " << __FUNCTION__; + } + + // CookieStore implementation. + virtual bool SetCookieWithOptions(const GURL& url, + const std::string& cookie_line, + const net::CookieOptions& options) { + // The cookie_string_ is available only once, i.e. once it is read by + // it is invalidated. + cookie_string_ = cookie_line; + return true; + } + + virtual std::string GetCookiesWithOptions(const GURL& url, + const net::CookieOptions& options) { + return cookie_string_; + } + + virtual void DeleteCookie(const GURL& url, + const std::string& cookie_name) { + NOTREACHED() << "Should not get called for an automation profile"; + } + + virtual net::CookieMonster* GetCookieMonster() { + NOTREACHED() << "Should not get called for an automation profile"; + return NULL; + } + + protected: + void SendIPCMessageOnIOThread(IPC::Message* m) { + if (ChromeThread::CurrentlyOn(ChromeThread::IO)) { + automation_client_->Send(m); + } else { + Task* task = NewRunnableMethod(this, + &AutomationCookieStore::SendIPCMessageOnIOThread, m); + ChromeThread::PostTask(ChromeThread::IO, FROM_HERE, task); + } + } + + net::CookieStore* original_cookie_store_; + scoped_refptr<AutomationResourceMessageFilter> automation_client_; + int tab_handle_; + std::string cookie_string_; + + private: + DISALLOW_COPY_AND_ASSIGN(AutomationCookieStore); +}; + +// CookiePolicy specialization for automation specific cookie policies. +class AutomationCookiePolicy : public net::CookiePolicy { + public: + AutomationCookiePolicy(AutomationResourceMessageFilter* automation_client, + int tab_handle, net::CookieStore* cookie_store) + : automation_client_(automation_client), + tab_handle_(tab_handle), + cookie_store_(cookie_store) {} + + virtual int CanGetCookies(const GURL& url, + const GURL& first_party_for_cookies, + net::CompletionCallback* callback) { + DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO)); + + if (automation_client_.get()) { + automation_client_->GetCookiesForUrl(tab_handle_, url, callback, + cookie_store_.get()); + return net::ERR_IO_PENDING; + } + return net::ERR_ACCESS_DENIED; + } + + virtual int CanSetCookie(const GURL& url, + const GURL& first_party_for_cookies, + const std::string& cookie_line, + net::CompletionCallback* callback) { + if (automation_client_.get()) { + automation_client_->Send(new AutomationMsg_SetCookieAsync(0, + tab_handle_, url, cookie_line)); + } + return net::ERR_ACCESS_DENIED; + } + + private: + scoped_refptr<AutomationResourceMessageFilter> automation_client_; + int tab_handle_; + scoped_refptr<net::CookieStore> cookie_store_; + + DISALLOW_COPY_AND_ASSIGN(AutomationCookiePolicy); +}; + +class Factory : public ChromeURLRequestContextFactory { + public: + Factory(ChromeURLRequestContextGetter* original_context_getter, + Profile* profile, + AutomationResourceMessageFilter* automation_client, + int tab_handle) + : ChromeURLRequestContextFactory(profile), + original_context_getter_(original_context_getter), + automation_client_(automation_client), + tab_handle_(tab_handle) { + } + + virtual ChromeURLRequestContext* Create() { + ChromeURLRequestContext* original_context = + original_context_getter_->GetIOContext(); + + // Create an automation cookie store. + scoped_refptr<net::CookieStore> automation_cookie_store = + new AutomationCookieStore(original_context->cookie_store(), + automation_client_, + tab_handle_); + + // Create an automation cookie policy. + AutomationCookiePolicy* automation_cookie_policy = + new AutomationCookiePolicy(automation_client_, + tab_handle_, + automation_cookie_store); + + return new AutomationURLRequestContext(original_context, + automation_cookie_store, + automation_cookie_policy); + } + + private: + scoped_refptr<ChromeURLRequestContextGetter> original_context_getter_; + scoped_refptr<AutomationResourceMessageFilter> automation_client_; + int tab_handle_; +}; + +ChromeURLRequestContextGetter* CreateAutomationURLRequestContextForTab( + int tab_handle, + Profile* profile, + AutomationResourceMessageFilter* automation_client) { + ChromeURLRequestContextGetter* original_context = + static_cast<ChromeURLRequestContextGetter*>( + profile->GetRequestContext()); + + ChromeURLRequestContextGetter* request_context = + new ChromeURLRequestContextGetter( + NULL, // Don't register an observer on PrefService. + new Factory(original_context, profile, automation_client, + tab_handle)); + return request_context; +} + +} // namespace AutomationRequestContext + |