diff options
24 files changed, 119 insertions, 267 deletions
diff --git a/chrome/browser/chrome_content_browser_client.cc b/chrome/browser/chrome_content_browser_client.cc index 7ea7bbc..c77cd39 100644 --- a/chrome/browser/chrome_content_browser_client.cc +++ b/chrome/browser/chrome_content_browser_client.cc @@ -21,7 +21,6 @@ #include "chrome/browser/extensions/extension_service.h" #include "chrome/browser/extensions/extension_web_ui.h" #include "chrome/browser/google/google_util.h" -#include "chrome/browser/net/chrome_net_log.h" #include "chrome/browser/notifications/desktop_notification_service.h" #include "chrome/browser/notifications/desktop_notification_service_factory.h" #include "chrome/browser/platform_util.h" @@ -690,10 +689,6 @@ DevToolsManager* ChromeContentBrowserClient::GetDevToolsManager() { return g_browser_process->devtools_manager(); } -net::NetLog* ChromeContentBrowserClient::GetNetLog() { - return g_browser_process->net_log(); -} - bool ChromeContentBrowserClient::IsFastShutdownPossible() { const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess(); return !browser_command_line.HasSwitch(switches::kChromeFrame); diff --git a/chrome/browser/chrome_content_browser_client.h b/chrome/browser/chrome_content_browser_client.h index 6de30f3..cfbd2d9 100644 --- a/chrome/browser/chrome_content_browser_client.h +++ b/chrome/browser/chrome_content_browser_client.h @@ -94,7 +94,6 @@ class ChromeContentBrowserClient : public content::ContentBrowserClient { virtual ui::Clipboard* GetClipboard() OVERRIDE; virtual MHTMLGenerationManager* GetMHTMLGenerationManager() OVERRIDE; virtual DevToolsManager* GetDevToolsManager() OVERRIDE; - virtual net::NetLog* GetNetLog() OVERRIDE; virtual bool IsFastShutdownPossible() OVERRIDE; virtual WebPreferences GetWebkitPrefs(Profile* profile, bool is_web_ui) OVERRIDE; diff --git a/chrome/browser/net/chrome_net_log.cc b/chrome/browser/net/chrome_net_log.cc index 212dc46..3c9625d 100644 --- a/chrome/browser/net/chrome_net_log.cc +++ b/chrome/browser/net/chrome_net_log.cc @@ -16,70 +16,30 @@ #include "chrome/browser/net/passive_log_collector.h" #include "chrome/common/chrome_switches.h" -ChromeNetLog::ThreadSafeObserverImpl::ThreadSafeObserverImpl(LogLevel log_level) +ChromeNetLog::ThreadSafeObserver::ThreadSafeObserver(LogLevel log_level) : net_log_(NULL), - ALLOW_THIS_IN_INITIALIZER_LIST(internal_observer_(this, log_level)) { + log_level_(log_level) { } -ChromeNetLog::ThreadSafeObserverImpl::~ThreadSafeObserverImpl() { +ChromeNetLog::ThreadSafeObserver::~ThreadSafeObserver() { DCHECK(!net_log_); } -void ChromeNetLog::ThreadSafeObserverImpl::AddAsObserver( - ChromeNetLog* net_log) { - DCHECK(!net_log_); - net_log_ = net_log; - net_log_->AddThreadSafeObserver(&internal_observer_); -} - -void ChromeNetLog::ThreadSafeObserverImpl::RemoveAsObserver() { - DCHECK(net_log_); - net_log_->RemoveThreadSafeObserver(&internal_observer_); - net_log_ = NULL; -} - -void ChromeNetLog::ThreadSafeObserverImpl::SetLogLevel( - net::NetLog::LogLevel log_level) { - DCHECK(net_log_); - base::AutoLock lock(net_log_->lock_); - internal_observer_.SetLogLevel(log_level); - net_log_->UpdateLogLevel(); +net::NetLog::LogLevel ChromeNetLog::ThreadSafeObserver::log_level() const { + return log_level_; } -void ChromeNetLog::ThreadSafeObserverImpl:: -AddAsObserverAndGetAllPassivelyCapturedEvents( - ChromeNetLog* net_log, - EntryList* entries) { - DCHECK(!net_log_); - net_log_ = net_log; - net_log_->AddObserverAndGetAllPassivelyCapturedEvents(&internal_observer_, - entries); -} - -void ChromeNetLog::ThreadSafeObserverImpl::AssertNetLogLockAcquired() const { +void ChromeNetLog::ThreadSafeObserver::AssertNetLogLockAcquired() const { if (net_log_) net_log_->lock_.AssertAcquired(); } -ChromeNetLog::ThreadSafeObserverImpl::PassThroughObserver::PassThroughObserver( - ChromeNetLog::ThreadSafeObserverImpl* owner, - net::NetLog::LogLevel log_level) - : net::NetLog::ThreadSafeObserver(log_level), - ALLOW_THIS_IN_INITIALIZER_LIST(owner_(owner)) { -} - -void ChromeNetLog::ThreadSafeObserverImpl::PassThroughObserver::OnAddEntry( - net::NetLog::EventType type, - const base::TimeTicks& time, - const net::NetLog::Source& source, - net::NetLog::EventPhase phase, - net::NetLog::EventParameters* params) { - owner_->OnAddEntry(type, time, source, phase, params); -} - -void ChromeNetLog::ThreadSafeObserverImpl::PassThroughObserver::SetLogLevel( +void ChromeNetLog::ThreadSafeObserver::SetLogLevel( net::NetLog::LogLevel log_level) { + DCHECK(net_log_); + base::AutoLock lock(net_log_->lock_); log_level_ = log_level; + net_log_->UpdateLogLevel(); } ChromeNetLog::Entry::Entry(uint32 order, @@ -119,21 +79,21 @@ ChromeNetLog::ChromeNetLog() } } - passive_collector_->AddAsObserver(this); - load_timing_observer_->AddAsObserver(this); + AddObserver(passive_collector_.get()); + AddObserver(load_timing_observer_.get()); if (command_line->HasSwitch(switches::kLogNetLog)) { net_log_logger_.reset(new NetLogLogger( - command_line->GetSwitchValuePath(switches::kLogNetLog))); - net_log_logger_->AddAsObserver(this); + command_line->GetSwitchValuePath(switches::kLogNetLog))); + AddObserver(net_log_logger_.get()); } } ChromeNetLog::~ChromeNetLog() { - passive_collector_->RemoveAsObserver(); - load_timing_observer_->RemoveAsObserver(); + RemoveObserver(passive_collector_.get()); + RemoveObserver(load_timing_observer_.get()); if (net_log_logger_.get()) { - net_log_logger_->RemoveAsObserver(); + RemoveObserver(net_log_logger_.get()); } } @@ -159,21 +119,21 @@ net::NetLog::LogLevel ChromeNetLog::GetLogLevel() const { return static_cast<net::NetLog::LogLevel>(log_level); } -void ChromeNetLog::AddThreadSafeObserver( - net::NetLog::ThreadSafeObserver* observer) { +void ChromeNetLog::AddObserver(ThreadSafeObserver* observer) { base::AutoLock lock(lock_); AddObserverWhileLockHeld(observer); } -void ChromeNetLog::RemoveThreadSafeObserver( - net::NetLog::ThreadSafeObserver* observer) { +void ChromeNetLog::RemoveObserver(ThreadSafeObserver* observer) { base::AutoLock lock(lock_); + DCHECK_EQ(observer->net_log_, this); + observer->net_log_ = NULL; observers_.RemoveObserver(observer); UpdateLogLevel(); } void ChromeNetLog::AddObserverAndGetAllPassivelyCapturedEvents( - net::NetLog::ThreadSafeObserver* observer, EntryList* passive_entries) { + ThreadSafeObserver* observer, EntryList* passive_entries) { base::AutoLock lock(lock_); AddObserverWhileLockHeld(observer); passive_collector_->GetAllCapturedEvents(passive_entries); @@ -205,8 +165,9 @@ void ChromeNetLog::UpdateLogLevel() { new_effective_log_level); } -void ChromeNetLog::AddObserverWhileLockHeld( - net::NetLog::ThreadSafeObserver* observer) { +void ChromeNetLog::AddObserverWhileLockHeld(ThreadSafeObserver* observer) { + DCHECK(!observer->net_log_); + observer->net_log_ = this; observers_.AddObserver(observer); UpdateLogLevel(); } diff --git a/chrome/browser/net/chrome_net_log.h b/chrome/browser/net/chrome_net_log.h index a032c33..909ca0a 100644 --- a/chrome/browser/net/chrome_net_log.h +++ b/chrome/browser/net/chrome_net_log.h @@ -23,7 +23,7 @@ class PassiveLogCollector; // messages to a list of observers. // // All methods are thread safe, with the exception that no ChromeNetLog or -// ChromeNetLog::ThreadSafeObserverImpl functions may be called by an observer's +// ChromeNetLog::ThreadSafeObserver functions may be called by an observer's // OnAddEntry() method. Doing so will result in a deadlock. // // By default, ChromeNetLog will attach the observer PassiveLogCollector which @@ -54,73 +54,53 @@ class ChromeNetLog : public net::NetLog { typedef std::vector<Entry> EntryList; - // Base class for observing the events logged by the network - // stack. This has some nice-to-have functionality for use by code - // within chrome/, but any net::NetLog::ThreadSafeObserver may be - // registered to observe the NetLog. - // - // This class uses composition rather than inheritance so that - // certain invariants can be maintained when subclasses of it are - // added as observers (through the AddAsObserver and - // RemoveAsObserver methods on this class). - class ThreadSafeObserverImpl { + // Interface for observing the events logged by the network stack. + class ThreadSafeObserver { public: + // Constructs an observer that wants to see network events, with + // the specified minimum event granularity. A ThreadSafeObserver can only + // observe a single ChromeNetLog at a time. + // + // Typical observers should specify LOG_BASIC. + // // Observers that need to see the full granularity of events can // specify LOG_ALL. However doing so will have performance consequences, // and may cause PassiveLogCollector to use more memory than anticipated. - explicit ThreadSafeObserverImpl(LogLevel log_level); - virtual ~ThreadSafeObserverImpl(); - + // + // Observers will be called on the same thread an entry is added on, + // and are responsible for ensuring their own thread safety. + explicit ThreadSafeObserver(LogLevel log_level); + + virtual ~ThreadSafeObserver(); + + // This method will be called on the thread that the event occurs on. It + // is the responsibility of the observer to handle it in a thread safe + // manner. + // + // It is illegal for an Observer to call any ChromeNetLog or + // ChromeNetLog::ThreadSafeObserver functions in response to a call to + // OnAddEntry. virtual void OnAddEntry(EventType type, const base::TimeTicks& time, const Source& source, EventPhase phase, EventParameters* params) = 0; - - // These must be used instead of - // ChromeNetLog::Add/RemoveThreadSafeObserver to manage the - // association in this class with a given ChromeNetLog instance. - void AddAsObserver(ChromeNetLog* net_log); - void RemoveAsObserver(); - - void SetLogLevel(LogLevel log_level); - - void AddAsObserverAndGetAllPassivelyCapturedEvents( - ChromeNetLog *net_log, - EntryList* passive_entries); + LogLevel log_level() const; protected: void AssertNetLogLockAcquired() const; - private: - class PassThroughObserver : public ThreadSafeObserver { - public: - PassThroughObserver(ThreadSafeObserverImpl* owner, LogLevel log_level); - virtual ~PassThroughObserver() {} - virtual void OnAddEntry(EventType type, - const base::TimeTicks& time, - const Source& source, - EventPhase phase, - EventParameters* params) OVERRIDE; - - // Can only be called when actively observing a ChromeNetLog. - void SetLogLevel(LogLevel log_level); - - private: - ThreadSafeObserverImpl* owner_; - }; - - friend class PassThroughObserver; - - // ChromeNetLog currently being observed. Set by - // AddAsObserver/RemoveAsObserver. - ChromeNetLog* net_log_; + // Can only be called when actively observing a ChromeNetLog. + void SetLogLevel(LogLevel log_level); - // The observer we register in AddAsObserver, that passes stuff - // through to us. - PassThroughObserver internal_observer_; + // ChromeNetLog currently being observed, if any. Set by ChromeNetLog's + // AddObserver and RemoveObserver methods. + ChromeNetLog* net_log_; - DISALLOW_COPY_AND_ASSIGN(ThreadSafeObserverImpl); + private: + friend class ChromeNetLog; + LogLevel log_level_; + DISALLOW_COPY_AND_ASSIGN(ThreadSafeObserver); }; ChromeNetLog(); @@ -131,9 +111,19 @@ class ChromeNetLog : public net::NetLog { const base::TimeTicks& time, const Source& source, EventPhase phase, - EventParameters* params) OVERRIDE; - virtual uint32 NextID() OVERRIDE; - virtual LogLevel GetLogLevel() const OVERRIDE; + EventParameters* params); + virtual uint32 NextID(); + virtual LogLevel GetLogLevel() const; + + void AddObserver(ThreadSafeObserver* observer); + void RemoveObserver(ThreadSafeObserver* observer); + + // Adds |observer| and writes all passively captured events to + // |passive_entries|. Guarantees that no events in |passive_entries| will be + // sent to |observer| and all future events that have yet been sent to the + // PassiveLogCollector will be sent to |observer|. + void AddObserverAndGetAllPassivelyCapturedEvents(ThreadSafeObserver* observer, + EntryList* passive_entries); void GetAllPassivelyCapturedEvents(EntryList* passive_entries); @@ -146,18 +136,6 @@ class ChromeNetLog : public net::NetLog { private: void AddObserverWhileLockHeld(ThreadSafeObserver* observer); - // NetLog implementation - virtual void AddThreadSafeObserver(ThreadSafeObserver* observer) OVERRIDE; - virtual void RemoveThreadSafeObserver(ThreadSafeObserver* observer) OVERRIDE; - - // Adds |observer| and writes all passively captured events to - // |passive_entries|. Guarantees that no events in |passive_entries| will be - // sent to |observer| and all future events that have yet been sent to the - // PassiveLogCollector will be sent to |observer|. - void AddObserverAndGetAllPassivelyCapturedEvents(ThreadSafeObserver* observer, - EntryList* passive_entries); - - // Called whenever an observer is added or removed, or changes its log level. // Must have acquired |lock_| prior to calling. void UpdateLogLevel(); diff --git a/chrome/browser/net/load_timing_observer.cc b/chrome/browser/net/load_timing_observer.cc index 788394f..e891075 100644 --- a/chrome/browser/net/load_timing_observer.cc +++ b/chrome/browser/net/load_timing_observer.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2010 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. @@ -62,7 +62,7 @@ LoadTimingObserver::HTTPStreamJobRecord::HTTPStreamJobRecord() } LoadTimingObserver::LoadTimingObserver() - : ThreadSafeObserverImpl(net::NetLog::LOG_BASIC), + : ThreadSafeObserver(net::NetLog::LOG_BASIC), last_connect_job_id_(net::NetLog::Source::kInvalidId) { } diff --git a/chrome/browser/net/load_timing_observer.h b/chrome/browser/net/load_timing_observer.h index 7f7f49e..c1f8cd4 100644 --- a/chrome/browser/net/load_timing_observer.h +++ b/chrome/browser/net/load_timing_observer.h @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2010 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. @@ -24,7 +24,7 @@ struct ResourceResponse; // // LoadTimingObserver lives completely on the IOThread and ignores events from // other threads. It is not safe to use from other threads. -class LoadTimingObserver : public ChromeNetLog::ThreadSafeObserverImpl { +class LoadTimingObserver : public ChromeNetLog::ThreadSafeObserver { public: struct URLRequestRecord { URLRequestRecord(); diff --git a/chrome/browser/net/net_log_logger.cc b/chrome/browser/net/net_log_logger.cc index fac5c82..6c79278 100644 --- a/chrome/browser/net/net_log_logger.cc +++ b/chrome/browser/net/net_log_logger.cc @@ -14,7 +14,7 @@ #include "chrome/browser/ui/webui/net_internals_ui.h" NetLogLogger::NetLogLogger(const FilePath &log_path) - : ThreadSafeObserverImpl(net::NetLog::LOG_ALL_BUT_BYTES) { + : ThreadSafeObserver(net::NetLog::LOG_ALL_BUT_BYTES) { if (!log_path.empty()) { base::ThreadRestrictions::ScopedAllowIO allow_io; file_.Set(file_util::OpenFile(log_path, "w")); diff --git a/chrome/browser/net/net_log_logger.h b/chrome/browser/net/net_log_logger.h index f04fcc8..1ad1244 100644 --- a/chrome/browser/net/net_log_logger.h +++ b/chrome/browser/net/net_log_logger.h @@ -21,7 +21,7 @@ class FilePath; // // Relies on ChromeNetLog only calling an Observer once at a time for // thread-safety. -class NetLogLogger : public ChromeNetLog::ThreadSafeObserverImpl { +class NetLogLogger : public ChromeNetLog::ThreadSafeObserver { public: // If |log_path| is empty or file creation fails, writes to VLOG(1). // Otherwise, writes to |log_path|. Uses one line per entry, for diff --git a/chrome/browser/net/passive_log_collector.cc b/chrome/browser/net/passive_log_collector.cc index 66950ad..ca321dd 100644 --- a/chrome/browser/net/passive_log_collector.cc +++ b/chrome/browser/net/passive_log_collector.cc @@ -50,7 +50,7 @@ PassiveLogCollector::SourceInfo::~SourceInfo() {} //---------------------------------------------------------------------------- PassiveLogCollector::PassiveLogCollector() - : ThreadSafeObserverImpl(net::NetLog::LOG_BASIC), + : ThreadSafeObserver(net::NetLog::LOG_BASIC), ALLOW_THIS_IN_INITIALIZER_LIST(connect_job_tracker_(this)), ALLOW_THIS_IN_INITIALIZER_LIST(url_request_tracker_(this)), ALLOW_THIS_IN_INITIALIZER_LIST(socket_stream_tracker_(this)), diff --git a/chrome/browser/net/passive_log_collector.h b/chrome/browser/net/passive_log_collector.h index ae85f56..28598b2 100644 --- a/chrome/browser/net/passive_log_collector.h +++ b/chrome/browser/net/passive_log_collector.h @@ -36,7 +36,7 @@ // The PassiveLogCollector is owned by the ChromeNetLog itself, and is not // thread safe. The ChromeNetLog is responsible for calling it in a thread safe // manner. -class PassiveLogCollector : public ChromeNetLog::ThreadSafeObserverImpl { +class PassiveLogCollector : public ChromeNetLog::ThreadSafeObserver { public: typedef std::vector<net::NetLog::Source> SourceDependencyList; diff --git a/chrome/browser/ui/webui/media/media_internals_proxy.cc b/chrome/browser/ui/webui/media/media_internals_proxy.cc index db3788d..2f2e46a 100644 --- a/chrome/browser/ui/webui/media/media_internals_proxy.cc +++ b/chrome/browser/ui/webui/media/media_internals_proxy.cc @@ -23,7 +23,7 @@ static const char kSendConstantsFunction[] = "media.onReceiveConstants"; static const char kSendNetworkEventsFunction[] = "media.onNetUpdate"; MediaInternalsProxy::MediaInternalsProxy() - : ThreadSafeObserverImpl(net::NetLog::LOG_ALL_BUT_BYTES) { + : ThreadSafeObserver(net::NetLog::LOG_ALL_BUT_BYTES) { io_thread_ = g_browser_process->io_thread(); } @@ -118,13 +118,13 @@ void MediaInternalsProxy::ObserveMediaInternalsOnIOThread() { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); io_thread_->globals()->media.media_internals->AddObserver(this); // TODO(scottfr): Get the passive log data as well. - AddAsObserver(io_thread_->net_log()); + io_thread_->net_log()->AddObserver(this); } void MediaInternalsProxy::StopObservingMediaInternalsOnIOThread() { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); io_thread_->globals()->media.media_internals->RemoveObserver(this); - RemoveAsObserver(); + io_thread_->net_log()->RemoveObserver(this); } void MediaInternalsProxy::GetEverythingOnIOThread() { diff --git a/chrome/browser/ui/webui/media/media_internals_proxy.h b/chrome/browser/ui/webui/media/media_internals_proxy.h index 229b4c3..1915e94 100644 --- a/chrome/browser/ui/webui/media/media_internals_proxy.h +++ b/chrome/browser/ui/webui/media/media_internals_proxy.h @@ -26,7 +26,7 @@ class Value; class MediaInternalsProxy : public MediaInternalsObserver, public base::RefCountedThreadSafe<MediaInternalsProxy>, - public ChromeNetLog::ThreadSafeObserverImpl { + public ChromeNetLog::ThreadSafeObserver { public: MediaInternalsProxy(); @@ -47,7 +47,7 @@ class MediaInternalsProxy const base::TimeTicks& time, const net::NetLog::Source& source, net::NetLog::EventPhase phase, - net::NetLog::EventParameters* params) OVERRIDE; + net::NetLog::EventParameters* params); private: friend class base::RefCountedThreadSafe<MediaInternalsProxy>; diff --git a/chrome/browser/ui/webui/net_internals_ui.cc b/chrome/browser/ui/webui/net_internals_ui.cc index 154343c..bef57d6 100644 --- a/chrome/browser/ui/webui/net_internals_ui.cc +++ b/chrome/browser/ui/webui/net_internals_ui.cc @@ -275,7 +275,7 @@ class NetInternalsMessageHandler::IOThreadImpl : public base::RefCountedThreadSafe< NetInternalsMessageHandler::IOThreadImpl, BrowserThread::DeleteOnUIThread>, - public ChromeNetLog::ThreadSafeObserverImpl, + public ChromeNetLog::ThreadSafeObserver, public ConnectionTester::Delegate { public: // Type for methods that can be used as MessageHandler callbacks. @@ -761,7 +761,7 @@ NetInternalsMessageHandler::IOThreadImpl::IOThreadImpl( const base::WeakPtr<NetInternalsMessageHandler>& handler, IOThread* io_thread, net::URLRequestContextGetter* context_getter) - : ThreadSafeObserverImpl(net::NetLog::LOG_ALL_BUT_BYTES), + : ThreadSafeObserver(net::NetLog::LOG_ALL_BUT_BYTES), handler_(handler), io_thread_(io_thread), context_getter_(context_getter), @@ -784,10 +784,8 @@ NetInternalsMessageHandler::IOThreadImpl::CreateCallback( void NetInternalsMessageHandler::IOThreadImpl::Detach() { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); // Unregister with network stack to observe events. - if (is_observing_log_) { - is_observing_log_ = false; - RemoveAsObserver(); - } + if (is_observing_log_) + io_thread_->net_log()->RemoveObserver(this); // Cancel any in-progress connection tests. connection_tester_.reset(); @@ -826,8 +824,8 @@ void NetInternalsMessageHandler::IOThreadImpl::OnRendererReady( // Register with network stack to observe events. is_observing_log_ = true; ChromeNetLog::EntryList entries; - AddAsObserverAndGetAllPassivelyCapturedEvents(io_thread_->net_log(), - &entries); + io_thread_->net_log()->AddObserverAndGetAllPassivelyCapturedEvents(this, + &entries); SendPassiveLogEntries(entries); } diff --git a/content/browser/content_browser_client.h b/content/browser/content_browser_client.h index a04cee0..5478c7d 100644 --- a/content/browser/content_browser_client.h +++ b/content/browser/content_browser_client.h @@ -42,7 +42,6 @@ class CryptoModuleBlockingPasswordDelegate; namespace net { class CookieList; class CookieOptions; -class NetLog; class URLRequest; class URLRequestContext; class X509Certificate; @@ -236,7 +235,6 @@ class ContentBrowserClient { virtual ui::Clipboard* GetClipboard() = 0; virtual MHTMLGenerationManager* GetMHTMLGenerationManager() = 0; virtual DevToolsManager* GetDevToolsManager() = 0; - virtual net::NetLog* GetNetLog() = 0; // Returns true if fast shutdown is possible. virtual bool IsFastShutdownPossible() = 0; diff --git a/content/browser/debugger/DEPS b/content/browser/debugger/DEPS index db358e1..558fbbd 100644 --- a/content/browser/debugger/DEPS +++ b/content/browser/debugger/DEPS @@ -9,11 +9,15 @@ include_rules = [ # devtools_manager.cc, http://codereview.chromium.org/7310029/ "+chrome/browser/browser_process.h", + "+chrome/browser/net/chrome_net_log.h", + + # devtools_net_log_observer.cc + "+chrome/browser/io_thread.h", # worker_devtools_manager_io.cc "+chrome/browser/debugger/devtools_window.h", "+chrome/browser/profiles/profile_manager.h", - + # devtools_http_protocol_handler.cc "+ui/base/resource/resource_bundle.h", "+chrome/browser/ui/webui/devtools_ui.h", diff --git a/content/browser/debugger/devtools_manager.cc b/content/browser/debugger/devtools_manager.cc index c79aee7..bc8d4f9 100644 --- a/content/browser/debugger/devtools_manager.cc +++ b/content/browser/debugger/devtools_manager.cc @@ -247,7 +247,8 @@ void DevToolsManager::BindClientHost( BrowserThread::PostTask( BrowserThread::IO, FROM_HERE, - NewRunnableFunction(&DevToolsNetLogObserver::Attach)); + NewRunnableFunction(&DevToolsNetLogObserver::Attach, + g_browser_process->io_thread())); } inspected_rvh_to_client_host_[inspected_rvh] = client_host; client_host_to_inspected_rvh_[client_host] = inspected_rvh; diff --git a/content/browser/debugger/devtools_netlog_observer.cc b/content/browser/debugger/devtools_netlog_observer.cc index 9e278b0..919c53c 100644 --- a/content/browser/debugger/devtools_netlog_observer.cc +++ b/content/browser/debugger/devtools_netlog_observer.cc @@ -7,8 +7,7 @@ #include "base/string_tokenizer.h" #include "base/string_util.h" #include "base/values.h" -#include "content/browser/browser_thread.h" -#include "content/browser/content_browser_client.h" +#include "chrome/browser/io_thread.h" #include "content/common/resource_response.h" #include "net/base/load_flags.h" #include "net/http/http_net_log_params.h" @@ -22,14 +21,14 @@ const size_t kMaxNumEntries = 1000; DevToolsNetLogObserver* DevToolsNetLogObserver::instance_ = NULL; -DevToolsNetLogObserver::DevToolsNetLogObserver(net::NetLog* net_log) - : net::NetLog::ThreadSafeObserver(net::NetLog::LOG_ALL_BUT_BYTES), - net_log_(net_log) { - net_log_->AddThreadSafeObserver(this); +DevToolsNetLogObserver::DevToolsNetLogObserver(ChromeNetLog* chrome_net_log) + : ChromeNetLog::ThreadSafeObserver(net::NetLog::LOG_ALL_BUT_BYTES), + chrome_net_log_(chrome_net_log) { + chrome_net_log_->AddObserver(this); } DevToolsNetLogObserver::~DevToolsNetLogObserver() { - net_log_->RemoveThreadSafeObserver(this); + chrome_net_log_->RemoveObserver(this); } DevToolsNetLogObserver::ResourceInfo* @@ -236,11 +235,11 @@ void DevToolsNetLogObserver::OnAddSocketEntry( } } -void DevToolsNetLogObserver::Attach() { +void DevToolsNetLogObserver::Attach(IOThread* io_thread) { + DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); DCHECK(!instance_); - instance_ = new DevToolsNetLogObserver( - content::GetContentClient()->browser()->GetNetLog()); + instance_ = new DevToolsNetLogObserver(io_thread->net_log()); } void DevToolsNetLogObserver::Detach() { diff --git a/content/browser/debugger/devtools_netlog_observer.h b/content/browser/debugger/devtools_netlog_observer.h index 3fe2765..75b3314 100644 --- a/content/browser/debugger/devtools_netlog_observer.h +++ b/content/browser/debugger/devtools_netlog_observer.h @@ -8,13 +8,14 @@ #include "base/hash_tables.h" #include "base/memory/ref_counted.h" -#include "net/base/net_log.h" +#include "chrome/browser/net/chrome_net_log.h" #include "webkit/glue/resource_loader_bridge.h" namespace net { class URLRequest; } // namespace net +class IOThread; struct ResourceResponse; // DevToolsNetLogObserver watches the NetLog event stream and collects the @@ -24,16 +25,16 @@ struct ResourceResponse; // As DevToolsNetLogObserver shares live data with objects that live on the // IO Thread, it must also reside on the IO Thread. Only OnAddEntry can be // called from other threads. -class DevToolsNetLogObserver : public net::NetLog::ThreadSafeObserver { +class DevToolsNetLogObserver: public ChromeNetLog::ThreadSafeObserver { typedef webkit_glue::ResourceDevToolsInfo ResourceInfo; public: - // net::NetLog::ThreadSafeObserver implementation: + // ThreadSafeObserver implementation: virtual void OnAddEntry(net::NetLog::EventType type, const base::TimeTicks& time, const net::NetLog::Source& source, net::NetLog::EventPhase phase, - net::NetLog::EventParameters* params) OVERRIDE; + net::NetLog::EventParameters* params); void OnAddURLRequestEntry(net::NetLog::EventType type, const base::TimeTicks& time, @@ -53,7 +54,7 @@ class DevToolsNetLogObserver : public net::NetLog::ThreadSafeObserver { net::NetLog::EventPhase phase, net::NetLog::EventParameters* params); - static void Attach(); + static void Attach(IOThread* thread); static void Detach(); // Must be called on the IO thread. May return NULL if no observers @@ -65,12 +66,12 @@ class DevToolsNetLogObserver : public net::NetLog::ThreadSafeObserver { private: static DevToolsNetLogObserver* instance_; - explicit DevToolsNetLogObserver(net::NetLog* net_log); + explicit DevToolsNetLogObserver(ChromeNetLog* chrome_net_log); virtual ~DevToolsNetLogObserver(); ResourceInfo* GetResourceInfo(uint32 id); - net::NetLog* net_log_; + ChromeNetLog* chrome_net_log_; typedef base::hash_map<uint32, scoped_refptr<ResourceInfo> > RequestToInfoMap; typedef base::hash_map<uint32, int> RequestToEncodedDataLengthMap; typedef base::hash_map<uint32, uint32> HTTPStreamJobToSocketMap; diff --git a/content/browser/mock_content_browser_client.cc b/content/browser/mock_content_browser_client.cc index 9d5c3e5..6ad3abf 100644 --- a/content/browser/mock_content_browser_client.cc +++ b/content/browser/mock_content_browser_client.cc @@ -188,10 +188,6 @@ DevToolsManager* MockContentBrowserClient::GetDevToolsManager() { return NULL; } -net::NetLog* MockContentBrowserClient::GetNetLog() { - return NULL; -} - bool MockContentBrowserClient::IsFastShutdownPossible() { return true; } diff --git a/content/browser/mock_content_browser_client.h b/content/browser/mock_content_browser_client.h index 157f9d3..ff00fec 100644 --- a/content/browser/mock_content_browser_client.h +++ b/content/browser/mock_content_browser_client.h @@ -94,7 +94,6 @@ class MockContentBrowserClient : public ContentBrowserClient { virtual ui::Clipboard* GetClipboard() OVERRIDE; virtual MHTMLGenerationManager* GetMHTMLGenerationManager() OVERRIDE; virtual DevToolsManager* GetDevToolsManager() OVERRIDE; - virtual net::NetLog* GetNetLog() OVERRIDE; virtual bool IsFastShutdownPossible() OVERRIDE; virtual WebPreferences GetWebkitPrefs(Profile* profile, bool is_web_ui) OVERRIDE; diff --git a/net/base/capturing_net_log.cc b/net/base/capturing_net_log.cc index ecdbc15..2daa73a 100644 --- a/net/base/capturing_net_log.cc +++ b/net/base/capturing_net_log.cc @@ -1,11 +1,9 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2010 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/base/capturing_net_log.h" -#include "base/logging.h" - namespace net { CapturingNetLog::Entry::Entry(EventType type, @@ -62,16 +60,6 @@ NetLog::LogLevel CapturingNetLog::GetLogLevel() const { return log_level_; } -void CapturingNetLog::AddThreadSafeObserver( - NetLog::ThreadSafeObserver* observer) { - NOTREACHED() << "Not currently used by net unit tests."; -} - -void CapturingNetLog::RemoveThreadSafeObserver( - NetLog::ThreadSafeObserver* observer) { - NOTREACHED() << "Not currently used by net unit tests."; -} - CapturingBoundNetLog::CapturingBoundNetLog(const NetLog::Source& source, CapturingNetLog* net_log) : source_(source), capturing_net_log_(net_log) { diff --git a/net/base/capturing_net_log.h b/net/base/capturing_net_log.h index f60f6ed..9185f48 100644 --- a/net/base/capturing_net_log.h +++ b/net/base/capturing_net_log.h @@ -10,7 +10,6 @@ #include "base/atomicops.h" #include "base/basictypes.h" -#include "base/compiler_specific.h" #include "base/memory/ref_counted.h" #include "base/memory/scoped_ptr.h" #include "base/synchronization/lock.h" @@ -61,11 +60,9 @@ class NET_API CapturingNetLog : public NetLog { const base::TimeTicks& time, const Source& source, EventPhase phase, - EventParameters* extra_parameters) OVERRIDE; - virtual uint32 NextID() OVERRIDE; - virtual LogLevel GetLogLevel() const OVERRIDE; - virtual void AddThreadSafeObserver(ThreadSafeObserver* observer) OVERRIDE; - virtual void RemoveThreadSafeObserver(ThreadSafeObserver* observer) OVERRIDE; + EventParameters* extra_parameters); + virtual uint32 NextID(); + virtual LogLevel GetLogLevel() const; private: // Needs to be "mutable" so can use it in GetEntries(). @@ -118,3 +115,4 @@ class NET_TEST CapturingBoundNetLog { } // namespace net #endif // NET_BASE_CAPTURING_NET_LOG_H_ + diff --git a/net/base/net_log.cc b/net/base/net_log.cc index 6509801..110c8a4 100644 --- a/net/base/net_log.cc +++ b/net/base/net_log.cc @@ -56,17 +56,6 @@ Value* NetLog::Source::ToValue() const { return dict; } -NetLog::ThreadSafeObserver::ThreadSafeObserver(LogLevel log_level) - : log_level_(log_level) { -} - -NetLog::ThreadSafeObserver::~ThreadSafeObserver() { -} - -NetLog::LogLevel NetLog::ThreadSafeObserver::log_level() const { - return log_level_; -} - // static std::string NetLog::TickCountToString(const base::TimeTicks& time) { int64 delta_time = (time - base::TimeTicks()).InMilliseconds(); diff --git a/net/base/net_log.h b/net/base/net_log.h index 051ba93..39fa915 100644 --- a/net/base/net_log.h +++ b/net/base/net_log.h @@ -104,50 +104,6 @@ class NET_API NetLog { LOG_BASIC, }; - // An observer, that must ensure its own thread safety, for events - // being added to a NetLog. - class ThreadSafeObserver { - public: - // Constructs an observer that wants to see network events, with - // the specified minimum event granularity. A ThreadSafeObserver can only - // observe a single NetLog at a time. - // - // Typical observers should specify LOG_BASIC. - // - // Observers that need to see the full granularity of events can - // specify LOG_ALL. However doing so will have performance consequences. - // - // Observers will be called on the same thread an entry is added on, - // and are responsible for ensuring their own thread safety. - explicit ThreadSafeObserver(LogLevel log_level); - virtual ~ThreadSafeObserver(); - - // Returns the minimum log level for events this observer wants to - // receive. - LogLevel log_level() const; - - // This method will be called on the thread that the event occurs on. It - // is the responsibility of the observer to handle it in a thread safe - // manner. - // - // It is illegal for an Observer to call any NetLog or - // NetLog::Observer functions in response to a call to OnAddEntry. - virtual void OnAddEntry(EventType type, - const base::TimeTicks& time, - const Source& source, - EventPhase phase, - EventParameters* params) = 0; - - protected: - // Subclasses should only ever modify this if they somehow - // collaborate with concrete implementations of NetLog to enable - // modification. - LogLevel log_level_; - - private: - DISALLOW_COPY_AND_ASSIGN(ThreadSafeObserver); - }; - NetLog() {} virtual ~NetLog() {} @@ -174,14 +130,6 @@ class NET_API NetLog { // and saving expensive log entries. virtual LogLevel GetLogLevel() const = 0; - // Adds an observer. Each observer may be added only once and must - // be removed via |RemoveObserver()| before this object goes out of - // scope. - virtual void AddThreadSafeObserver(ThreadSafeObserver* observer) = 0; - - // Removes an observer. - virtual void RemoveThreadSafeObserver(ThreadSafeObserver* observer) = 0; - // Converts a time to the string format that the NetLog uses to represent // times. Strings are used since integers may overflow. static std::string TickCountToString(const base::TimeTicks& time); |