webkit_remote 0.2.0 → 0.3.0

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 1.9.3
+before_install:
+  - "export DISPLAY=:99.0"
+  - "sh -e /etc/init.d/xvfb start"
+  - "sudo sh -c \"echo \\\"deb https://dl.google.com/linux/deb/ stable main\\\" >> /etc/apt/sources.list\""
+  - "sudo wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | sudo apt-key add -"
+  - "sudo apt-get -qq update"
+  - "sudo apt-get -qq install google-chrome-stable"

data/Gemfile

@@ -9,6 +9,7 @@ group :development do
   gem 'minitest', '>= 4.1.0'
   gem 'puma', '>= 1.6.3'
   gem 'rack', '>= 1.4.1'
+  gem 'rack-contrib', '>= 1.1.0'
   gem 'rdoc', '>= 3.12'
   gem 'ruby-prof', '>= 0.11.2'
   gem 'simplecov', '>= 0.7.1'

data/Gemfile.lock

@@ -17,6 +17,8 @@ GEM
     puma (1.6.3)
       rack (~> 1.2)
     rack (1.4.1)
+    rack-contrib (1.1.0)
+      rack (>= 0.9.1)
     rake (0.9.2.2)
     rdoc (3.12)
       json (~> 1.4)
@@ -39,6 +41,7 @@ DEPENDENCIES
   posix-spawn (>= 0.3.6)
   puma (>= 1.6.3)
   rack (>= 1.4.1)
+  rack-contrib (>= 1.1.0)
   rdoc (>= 3.12)
   ruby-prof (>= 0.11.2)
   simplecov (>= 0.7.1)

data/README.md

@@ -105,10 +105,10 @@ END_JS
 client.remote_eval('window').bound_call js_code, element, '你好'
 ```
 
-Finally, release the JavaScript objects that the debugger is holding onto.
+Finally, release the WebKit state that the debugger is holding onto.
 
 ```ruby
-element.group.release_all
+client.clear_all
 ```
 
 ### Read the Console
@@ -130,8 +130,13 @@ message.params
 message.stack_trace
 ```
 
+Again, release the WebKit state.
 
-### Clean Up
+```ruby
+client.clear_all
+```
+
+### Close the Browser
 
 ```ruby
 client.close

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/lib/webkit_remote.rb

@@ -9,6 +9,8 @@ require 'webkit_remote/client.rb'
 require 'webkit_remote/event.rb'
 require 'webkit_remote/client/console.rb'
 require 'webkit_remote/client/console_events.rb'
+require 'webkit_remote/client/network.rb'
+require 'webkit_remote/client/network_events.rb'
 require 'webkit_remote/client/page.rb'
 require 'webkit_remote/client/page_events.rb'
 require 'webkit_remote/client/runtime.rb'

data/lib/webkit_remote/client.rb

@@ -81,6 +81,23 @@ class Client
     events
   end
 
+  # Removes all the remote debugging data cached by this client.
+  #
+  # Some modules accumulate data throughout the debigging process. For example,
+  # WebkitRemote::Client::Remote#remote_eval and
+  # WebkitRemote::Events#ConsoleMessage build Ruby equivalents of the returned
+  # JavaScript objects, and prevent Chrome from garbage-collecting the
+  # returned JavaScript objects.
+  #
+  # Although modules have individual methods for releasing this data, such as
+  # WebkitRemote::Client::RemoteGroup#release, keeping track of individual data
+  # items is very inconvenient. Therefore, if you need to run a WebkitRemote
+  # client for an extended period of time, you might find it easier to
+  # periodically call this method.
+  def clear_all
+    clear_modules
+  end
+
   # @return [WebkitRemote::Rpc] the WebSocket RPC client; useful for making raw
   #     RPC calls to unsupported methods
   attr_reader :rpc
@@ -89,13 +106,6 @@ class Client
   #     tab debugged by this client
   attr_reader :browser
 
-  # Call by the constructor. Replaced by the module initializers.
-  #
-  # @private Hook for module initializers to do their own setups.
-  def initialize_modules
-    # NOTE: this gets called after all the module initializers complete
-  end
-
   # Registers a module initializer.
   def self.initializer(name)
     before_name = :"initialize_modules_before_#{name}"
@@ -108,6 +118,33 @@ class Client
       end
 END_METHOD
   end
+
+  # Registers a module clearer.
+  def self.clearer(name)
+    before_name = :"clear_modules_before_#{name}"
+    alias_method before_name, :clear_modules
+    remove_method :clear_modules
+    eval <<END_METHOD
+      def clear_modules
+        #{name}
+        #{before_name.to_s}
+      end
+END_METHOD
+  end
+
+  # Called by the constructor. Aliased by the module initializers.
+  #
+  # @private Hook for module initializers to do their own setups.
+  def initialize_modules
+    # NOTE: this gets called after all the module initializers complete
+  end
+
+  # Called by clear_all.
+  #
+  # @private Hook for modules to run their own clearing code.
+  def clear_modules
+    # NOTE: this gets called after all the module cleaners complete
+  end
 end  # class WebkitRemote::Client
 
 end  # namespace WebkitRemote

data/lib/webkit_remote/client/console.rb

@@ -4,14 +4,6 @@ class Client
 
 # API for the Console domain.
 module Console
-  # Removes all the messages in the console.
-  #
-  # @return [WebkitRemote::Client] self
-  def clear_console
-    @rpc.call 'Console.clearMessages'
-    self
-  end
-
   # Enables or disables the generation of events in the Console domain.
   #
   # @param [Boolean] new_console_events if true, the browser debugger will
@@ -19,22 +11,31 @@ module Console
   def console_events=(new_console_events)
     new_console_events = !!new_console_events
     if new_console_events != console_events
+      @rpc.call(new_console_events ? 'Console.enable' : 'Console.disable')
       @console_events = new_console_events
-      @rpc.call(@console_events ? 'Console.enable' : 'Console.disable')
     end
     new_console_events
   end
 
+  # Removes all the messages in the console.
+  #
+  # @return [WebkitRemote::Client] self
+  def clear_console
+    @rpc.call 'Console.clearMessages'
+    self
+  end
+
   # @return [Boolean] true if the debugger generates Console.* events
   attr_reader :console_events
 
   # @private Called by the Client constructor to set up Console data.
   def initialize_console
-    @console_events = nil
+    @console_events = false
   end
 end  # module WebkitRemote::Client::Console
 
 initializer :initialize_console
+clearer :clear_console
 include WebkitRemote::Client::Console
 
 end  # namespace WebkitRemote::Client

data/lib/webkit_remote/client/console_events.rb

@@ -65,26 +65,8 @@ class ConsoleMessage < WebkitRemote::Event
       else
         @reason = :other
       end
-      if raw_message['stackTrace']
-        @stack_trace = raw_message['stackTrace'].map do |raw_frame|
-          frame = {}
-          if raw_frame['columnNumber']
-            frame[:column] = raw_frame['columnNumber'].to_i
-          end
-          if raw_frame['lineNumber']
-            frame[:line] = raw_frame['lineNumber'].to_i
-          end
-          if raw_frame['functionName']
-            frame[:function] = raw_frame['functionName']
-          end
-          if raw_frame['url']
-            frame[:url] = raw_frame['url']
-          end
-          frame
-        end
-      else
-        @trace = nil
-      end
+      @stack_trace = WebkitRemote::Event::ConsoleMessage.parse_stack_trace(
+          raw_message['stackTrace'])
       @text = raw_message['text']
       @type = raw_message['type'] ? raw_message['type'].to_sym : nil
       @source_url = raw_message['url']
@@ -107,6 +89,33 @@ class ConsoleMessage < WebkitRemote::Event
   def self.can_reach?(client)
     client.console_events
   end
+
+
+  # Parses a StackTrace object returned by a RPC request.
+  #
+  # @param [Array<String, Object>] raw_stack_trace the raw StackTrace object
+  #     in the Console domain returned by a RPC request
+  # @return [Array<Symbol, Object>] Ruby-friendly stack trace
+  def self.parse_stack_trace(raw_stack_trace)
+    return nil unless raw_stack_trace
+
+    raw_stack_trace.map do |raw_frame|
+      frame = {}
+      if raw_frame['columnNumber']
+        frame[:column] = raw_frame['columnNumber'].to_i
+      end
+      if raw_frame['lineNumber']
+        frame[:line] = raw_frame['lineNumber'].to_i
+      end
+      if raw_frame['functionName']
+        frame[:function] = raw_frame['functionName']
+      end
+      if raw_frame['url']
+        frame[:url] = raw_frame['url']
+      end
+      frame
+    end
+  end
 end  # class WebkitRemote::Event::ConsoleMessage
 
 # Emitted when the same console message is produced repeatedly.

data/lib/webkit_remote/client/network.rb

@@ -0,0 +1,155 @@
+module WebkitRemote
+
+class Client
+
+# API for the Network domain.
+module Network
+  # Enables or disables the generation of events in the Network domain.
+  #
+  # @param [Boolean] new_network_events if true, the browser debugger will
+  #     generate Network.* events
+  def network_events=(new_network_events)
+    new_network_events = !!new_network_events
+    if new_network_events != network_events
+      @rpc.call(new_network_events ? 'Network.enable' : 'Network.disable')
+      @network_events = new_network_events
+    end
+    new_network_events
+  end
+
+  # Enables or disables the use of the network cache.
+  #
+  # @param [Boolean] new_disable_cache if true, the browser will not use its
+  #     network cache, and will always generate HTTP requests
+  def disable_cache=(new_disable_cache)
+    new_disable_cache = !!new_disable_cache
+    if new_disable_cache != disable_cache
+      @rpc.call 'Network.setCacheDisabled', cacheDisabled: new_disable_cache
+      @disable_cache = new_disable_cache
+    end
+    new_disable_cache
+  end
+
+  # Sets the User-Agent header that the browser will use to identify itself.
+  #
+  # @param [String] new_user_agent will be used instead of the browser's
+  #     hard-coded User-Agent header
+  def user_agent=(new_user_agent)
+    if new_user_agent != user_agent
+      @rpc.call 'Network.setUserAgentOverride', userAgent: new_user_agent
+      @user_agent = new_user_agent
+    end
+    new_user_agent
+  end
+
+  # Sets extra headers to be sent with every HTTP request.
+  #
+  # @param [Hash<String, String>] new_extra_headers HTTP headers to be added to
+  #     every HTTP request sent by the browser
+  def http_headers=(new_http_headers)
+    new_http_headers = Hash[new_http_headers.map { |k, v|
+      [k.to_s, v.to_s]
+    }].freeze
+    if new_http_headers != http_headers
+      @rpc.call 'Network.setExtraHTTPHeaders', headers: new_http_headers
+      @http_headers = new_http_headers
+    end
+    new_http_headers
+  end
+
+  # Checks if the debugger can clear the browser's cookies.
+  #
+  # @return [Boolean] true if WebkitRemote::Client::Network#clear_cookies can
+  #     be succesfully called
+  def can_clear_cookies?
+    response = @rpc.call 'Network.canClearBrowserCookies'
+    !!response['result']
+  end
+
+  # Removes all the cookies in the debugged browser.
+  #
+  # @return [WebkitRemote::Client] self
+  def clear_cookies
+    @rpc.call 'Network.clearBrowserCookies'
+    self
+  end
+
+  # Checks if the debugger can clear the browser's cache.
+  #
+  # @return [Boolean] true if WebkitRemote::Client::Network#clear_network_cache
+  #     can be succesfully called
+  def can_clear_network_cache?
+    response = @rpc.call 'Network.canClearBrowserCache'
+    !!response['result']
+  end
+
+  # Removes all the cached data in the debugged browser.
+  #
+  # @return [WebkitRemote::Client] self
+  def clear_network_cache
+    @rpc.call 'Network.clearBrowserCache'
+    self
+  end
+
+  # @return [Boolean] true if the debugger generates Network.* events
+  attr_reader :network_events
+
+  # @return [Array<WebkitRemote::Client::NetworkResource>] the resources
+  #     fetched during the debugging session
+  #
+  # This is only populated when Network events are received.
+  attr_reader :network_resources
+
+  # @return [Boolean] true if the browser's network cache is disabled, so every
+  #     resource load generates an HTTP request
+  attr_reader :disable_cache
+
+  # @return [String] replaces the brower's built-in User-Agent string
+  attr_reader :user_agent
+
+  # @return [Hash<String, String>]
+  attr_reader :http_headers
+
+  # Looks up network resources by IDs assigned by the WebKit remote debugger.
+  #
+  # @private Use the #resource property of Network events instead of calling
+  #     this directly.
+  #
+  # @param [String] remote_id the WebKit-assigned request_id
+  # @return [WebkitRemote::Client::NetworkResource] the cached information
+  #     about the resource with the given ID
+  def network_resource(remote_id)
+    if @network_resource_hash[remote_id]
+      return @network_resource_hash[remote_id]
+    end
+    resource = WebkitRemote::Client::NetworkResource.new remote_id, self
+
+    @network_resources << resource
+    @network_resource_hash[remote_id] = resource
+  end
+
+  # Removes the cached network request information.
+  #
+  # @return [WebkitRemote::Client] self
+  def clear_network
+    @network_resource_hash.clear
+    @network_resources.clear
+    self
+  end
+
+  # @private Called by the Client constructor to set up Network data.
+  def initialize_network
+    @disable_cache = false
+    @network_events = false
+    @network_resources = []
+    @network_resource_hash = {}
+    @user_agent = nil
+  end
+end  # module WebkitRemote::Client::Network
+
+initializer :initialize_network
+include WebkitRemote::Client::Network
+
+end  # namespace WebkitRemote::Client
+
+end  # namespace WebkitRemote

data/lib/webkit_remote/client/network_events.rb

@@ -0,0 +1,584 @@
+module WebkitRemote
+
+class Event
+
+# Emitted when a chunk of data is received over the network.
+class NetworkData < WebkitRemote::Event
+  register 'Network.dataReceived'
+
+  # @return [WebkitRemote::Client::NetworkResource] information about the
+  #     resource fetched by this network operation
+  attr_reader :resource
+
+  # @return [Number] the event timestamp
+  attr_reader :timestamp
+
+  # @return [Number] number of bytes actually received
+  attr_reader :bytes_received
+
+  # @return [Number] number of data bytes received (after decompression)
+  attr_reader :data_length
+
+  # @private Use Event#for instead of calling this constructor directly.
+  def initialize(rpc_event, client)
+    super
+    @data_length = raw_data['dataLength']
+    @bytes_received = raw_data['encodedDataLength']
+    @timestamp = raw_data['timestamp']
+
+    @resource = client.network_resource raw_data['requestId']
+    @resource.add_event self
+  end
+end  # class WebkitRemote::Event::NetworkData
+
+# Emitted when a resource fails to load.
+class NetworkFailure < WebkitRemote::Event
+  register 'Network.loadingFailed'
+
+  # @return [WebkitRemote::Client::NetworkResource] information about the
+  #     resource fetched by this network operation
+  attr_reader :resource
+
+  # @return [Number] the event timestamp
+  attr_reader :timestamp
+
+  # @return [String] the error message
+  attr_reader :error
+
+  # @return [Boolean] true if the request was canceled
+  #
+  # For example, CORS violations cause requests to be canceled.
+  attr_reader :canceled
+
+  # @private Use Event#for instead of calling this constructor directly.
+  def initialize(rpc_event, client)
+    super
+    @canceled = !!raw_data['canceled']
+    @error = raw_data['errorText']
+    @timestamp = raw_data['timestamp']
+
+    @resource = client.network_resource raw_data['requestId']
+    @resource.set_canceled @canceled
+    @resource.set_error @error
+    @resource.add_event self
+  end
+end  # class WebkitRemote::Event::NetworkFailure
+
+# Emitted when a resource finishes loading from the network.
+class NetworkLoad < WebkitRemote::Event
+  register 'Network.loadingFinished'
+
+  # @return [WebkitRemote::Client::NetworkResource] information about the
+  #     resource fetched by this network operation
+  attr_reader :resource
+
+  # @return [Number] the event timestamp
+  attr_reader :timestamp
+
+  # @private Use Event#for instead of calling this constructor directly.
+  def initialize(rpc_event, client)
+    super
+    @timestamp = raw_data['timestamp']
+
+    @resource = client.network_resource raw_data['requestId']
+    @resource.add_event self
+  end
+end  # class WebkitRemote::Event::NetworkLoad
+
+# Emitted when a resource is served from the local cache.
+class NetworkCacheHit < WebkitRemote::Event
+  register 'Network.requestServedFromCache'
+
+  # @return [WebkitRemote::Client::NetworkResource] information about the
+  #     resource fetched by this network operation
+  attr_reader :resource
+
+  # @private Use Event#for instead of calling this constructor directly.
+  def initialize(rpc_event, client)
+    super
+
+    @resource = client.network_resource raw_data['requestId']
+    @resource.add_event self
+  end
+end  # class WebkitRemote::Event::NetworkCacheHit
+
+# Emitted when a resource is served from the local cache.
+class NetworkMemoryCacheHit < WebkitRemote::Event
+  register 'Network.requestServedFromMemoryCache'
+
+  # @return [WebkitRemote::Client::NetworkResource] information about the
+  #     resource fetched by this network operation
+  attr_reader :resource
+
+  # @return [WebkitRemote::Client::NetworkCacheEntry] cached information used
+  #     to produce the resource
+  attr_reader :cache_data
+
+  # @return [String] the URL of the document that caused this network request
+  attr_reader :document_url
+
+  # @return [WebkitRemote::Client::NetworkRequestInitiator] cause for this
+  #     network request
+  attr_reader :initiator
+
+  # @return [Number] the event timestamp
+  attr_reader :timestamp
+
+  # @private Use Event#for instead of calling this constructor directly.
+  def initialize(rpc_event, client)
+    super
+
+    if raw_data['resource']
+      @cache_data = raw_data['resource']
+    end
+    @document_url = raw_data['documentURL']
+    if raw_data['initiator']
+      @initiator = WebkitRemote::Client::NetworkRequestInitiator.new(
+          raw_data['initiator'])
+    end
+    @loader_id = raw_data['loaderId']
+    @timestamp = raw_data['timestamp']
+
+    @resource = client.network_resource raw_data['requestId']
+    @resource.set_document_url @document_url
+    @resource.set_initiator @initiator
+    if @cache_data
+      @resource.set_response @cache_data.response
+      @resource.set_type @cache_data.type
+    end
+    @resource.add_event self
+  end
+end  # class WebkitRemote::Event::NetworkMemoryCacheHit
+
+# Emitted right before a network request.
+class NetworkRequest < WebkitRemote::Event
+  register 'Network.requestWillBeSent'
+
+  # @return [WebkitRemote::Client::NetworkResource] information about the
+  #     resource fetched by this network operation
+  attr_reader :resource
+
+  # @return [WebkitRemote::Client::NetworkRequest] information about this
+  #     network request
+  attr_reader :request
+
+  # @return [String] the URL of the document that caused this network request
+  attr_reader :document_url
+
+  # @return [WebkitRemote::Client::NetworkRequestInitiator] cause for this
+  #     network request
+  attr_reader :initiator
+
+  # @return [WebkitRemote::Client::NetworkResponse] the HTTP redirect that
+  #     caused this request; can be nil
+  attr_reader :redirect_response
+
+  # @return [String] used to correlate events
+  attr_reader :loader_id
+
+  # @return [Number] the event timestamp
+  attr_reader :timestamp
+
+  # @private Use Event#for instead of calling this constructor directly.
+  def initialize(rpc_event, client)
+    super
+    if raw_data['initiator']
+      @initiator = WebkitRemote::Client::NetworkRequestInitiator.new(
+          raw_data['initiator'])
+    end
+    @loader_id = raw_data['loaderId']
+    if raw_data['request']
+      @request = WebkitRemote::Client::NetworkRequest.new(
+          raw_data['request'])
+    end
+    if raw_data['redirectResponse']
+      @redirect_response = WebkitRemote::Client::NetworkResponse.new(
+          raw_data['redirectResponse'])
+    end
+    if raw_data['stackTrace']
+      @stack_trace = WebkitRemote::Event::ConsoleMessage.parse_stack_trace(
+          raw_initiator['stackTrace'])
+    else
+      @stack_trace = nil
+    end
+    @timestamp = raw_data['timestamp']
+
+    @resource = client.network_resource raw_data['requestId']
+    @resource.set_initiator @initiator
+    @resource.set_request @request
+    # TODO(pwnall): consider tracking redirects
+    @resource.add_event self
+  end
+
+  # @private Use Event#can_receive instead of calling this directly.
+  def self.can_reach?(client)
+    client.network_events
+  end
+end  # class WebkitRemote::Event::NetworkRequest
+
+# Emitted right after receiving a response to a network request.
+class NetworkResponse < WebkitRemote::Event
+  register 'Network.responseReceived'
+
+  # @return [WebkitRemote::Client::NetworkResource] information about the
+  #     resource fetched by this network operation
+  attr_reader :resource
+
+  # @return [WebkitRemote::Client::NetworkResponse] information about the HTTP
+  #     response behind this event
+  attr_reader :response
+
+  # @return [Symbol] the type of resource returned by this response; documented
+  #     values are :document, :font, :image, :other, :script, :stylesheet,
+  #     :websocket and :xhr
+  attr_reader :type
+
+  # @return [Number] the event timestamp
+  attr_reader :timestamp
+
+  # @return [String] used to correlate events
+  attr_reader :loader_id
+
+  # @private Use Event#for instead of calling this constructor directly.
+  def initialize(rpc_event, client)
+    super
+    @loader_id = raw_data['loaderId']
+    if raw_data['response']
+      @response = WebkitRemote::Client::NetworkResponse.new(
+          raw_data['response'])
+    end
+    @type = (raw_data['type'] || 'other').downcase.to_sym
+    @timestamp = raw_data['timestamp']
+
+    @resource = client.network_resource raw_data['requestId']
+    @resource.set_response @response
+    @resource.set_type @type
+    @resource.add_event self
+  end
+
+  # @private Use Event#can_receive instead of calling this directly.
+  def self.can_reach?(client)
+    client.network_events
+  end
+end  # class WebkitRemote::Event::NetworkResponse
+
+end  # namespace WebkitRemote::Event
+
+
+class Client
+
+# Wraps information about the network operations for retrieving a resource.
+class NetworkResource
+  # @return [WebkitRemote::Client::NetworkRequest] network request (most likely
+  #     HTTP) used to fetch this resource
+  attr_reader :request
+
+  # @return [WebkitRemote::Client::NetworkRequest] network response that
+  #     contains this resource
+  attr_reader :response
+
+  # @return [Symbol] the type of this resource; documented values are
+  #     :document, :font, :image, :other, :script, :stylesheet, :websocket and
+  #     :xhr
+  attr_reader :type
+
+  # @return [String] the URL of the document that referenced this resource
+  attr_reader :document_url
+
+  # @return [WebkitRemote::Client::NetworkRequestInitiator] cause for this
+  #     resource to be fetched from the network
+  attr_reader :initiator
+
+  # @return [Boolean] true if the request fetch was canceled
+  attr_reader :canceled
+
+  # @return [String] error message, if the resource fetching failed
+  attr_reader :error
+
+  # @return [WebkitRemote::Event] last event connected to this resource; can be
+  #     used to determine the resource's status
+  attr_reader :last_event
+
+  # @return [WebkitRemote::Client] remote debugging client that reported this
+  attr_reader :client
+
+  # @return [String] request_id assigned by the remote WebKit debugger
+  attr_reader :remote_id
+
+  # Creates an empty network operation wrapper.
+  #
+  # @private Use WebkitRemote::Client::Network#network_op instead of calling
+  #     this directly.
+  # @param [String] remote_id the request_id used by the remote debugging
+  #     server to identify this network operation
+  # @param [WebkitRemote::Client]
+  def initialize(remote_id, client)
+    @remote_id = remote_id
+    @client = client
+    @request = nil
+    @response = nil
+    @type = nil
+    @document_url = nil
+    @initiator = nil
+    @canceled = false
+    @last_event = nil
+  end
+
+  # @private Rely on the event processing code to set this property.
+  def set_canceled(new_canceled)
+    @canceled ||= new_canceled
+  end
+
+  # @private Rely on the event processing code to set this property.
+  def set_document_url(new_document_url)
+    return if new_document_url == nil
+    @document_url = new_document_url
+  end
+
+  # @private Rely on the event processing code to set this property.
+  def set_error(new_error)
+    return if new_error == nil
+    @error = new_error
+  end
+
+  # @private Rely on the event processing code to set this property.
+  def set_initiator(new_initiator)
+    return if new_initiator == nil
+    @initiator = new_initiator
+  end
+
+  # @private Rely on the event processing code to set this property.
+  def set_request(new_request)
+    return if new_request == nil
+    # TODO(pwnall): consider handling multiple requests
+    @request = new_request
+  end
+
+  # @private Rely on the event processing code to set this property.
+  def set_response(new_response)
+    return if new_response == nil
+    @response = new_response
+  end
+
+  # @private Rely on the event processing code to set this property.
+  def set_type(new_type)
+    return if new_type == nil
+    @type = new_type
+  end
+
+  # @private Rely on the event processing code to set this property.
+  def add_event(event)
+    @last_event = event
+    # TODO(pwnall): consider keeping track of all events
+  end
+end  # namespace WebkitRemote::Event
+
+# Wraps information about HTTP requests.
+class NetworkRequest
+  # @return [String] the URL of the request
+  attr_reader :url
+
+  # @return [Symbol, nil] HTTP request method, e.g. :get
+  attr_reader :method
+
+  # @return [Hash<String, String>] the HTTP headers of the request
+  attr_reader :headers
+
+  # @return [String] the body of a POST request
+  attr_reader :body
+
+  # @private use Event#for instead of calling this constructor directly
+  #
+  # @param [Hash<String, Number>] the raw RPC data for a Response object
+  #     in the Network domain
+  def initialize(raw_response)
+    @headers = raw_response['headers'] || {}
+    @method = raw_response['method'] ? raw_response['method'].downcase.to_sym :
+              nil
+    @body = raw_response['postData']
+    @url = raw_response['url']
+  end
+end  # class WebkitRemote::Client::NetworkRequest
+
+# Wraps information about responses to network requests.
+class NetworkResponse
+  # @return [String] the URL of the response
+  attr_reader :url
+
+  # @return [Number] HTTP status code
+  attr_reader :status
+
+  # @return [String] HTTP status message
+  attr_reader :status_text
+
+  # @return [Hash<String, String>] HTTP response headers
+  attr_reader :headers
+
+  # @return [String] the browser-determined response MIME type
+  attr_reader :mime_type
+
+  # @return [Hash<String, String>] HTTP request headers
+  attr_reader :request_headers
+
+  # @return [Boolean] true if the request was served from cache
+  attr_reader :from_cache
+
+  # @return [Number] id of the network connection used by the browser to fetch
+  #     this resource
+  attr_reader :connection_id
+
+  # @return [Boolean] true if the network connection used for this request was
+  #     already open
+  attr_reader :connection_reused
+
+  # @private use Event#for instead of calling this constructor directly
+  #
+  # @param [Hash<String, Number>] the raw RPC data for a Response object
+  #     in the Network domain
+  def initialize(raw_response)
+    @connection_id = raw_response['connectionId']
+    @connection_reused = raw_response['connectionReused'] || false
+    @from_cache = raw_response['fromDiskCache'] || false
+    @headers = raw_response['headers'] || {}
+    @mime_type = raw_response['mimeType']
+    @request_headers = raw_response['requestHeaders'] || {}
+    @status = raw_response['status']
+    @status_text = raw_response['statusText']
+    if raw_response['timing']
+      @timing = WebkitRemote::Client::NetworkResourceTiming.new(
+          raw_response['timing'])
+    else
+      @timing = nil
+    end
+    @url = raw_response['url']
+  end
+end  # class WebkitRemote::Client::NetworkResponse
+
+# Wraps timing information for network events.
+class NetworkResourceTiming
+  # @param [Number] baseline time for the HTTP request used to fetch a resource
+  attr_reader :time
+
+  # @param [Number] milliseconds from {#time} until the start of the server DNS
+  #     resolution
+  attr_reader :dns_start_ms
+
+  # @param [Number] milliseconds from {#time} until the server DNS resolution
+  #     completed
+  attr_reader :dns_end_ms
+
+  # @param [Number] milliseconds from {#time} until the start of the proxy DNS
+  #     resolution
+  attr_reader :proxy_start_ms
+
+  # @param [Number] milliseconds from {#time} until the proxy DNS resolution
+  #     completed
+  attr_reader :proxy_end_ms
+
+  # @param [Number] milliseconds from {#time} until the TCP connection
+  #     started being established
+  attr_reader :connect_start_ms
+
+  # @param [Number] milliseconds from {#time} until the TCP connection
+  #     was established
+  attr_reader :connect_end_ms
+
+  # @param [Number] milliseconds from {#time} until the start of the SSL
+  #     handshake
+  attr_reader :ssl_start_ms
+
+  # @param [Number] milliseconds from {#time} until the SSL handshake completed
+  attr_reader :ssl_end_ms
+
+  # @param [Number] milliseconds from {#time} until the HTTP request started
+  #     being transmitted
+  attr_reader :send_start_ms
+
+  # @param [Number] milliseconds from {#time} until the HTTP request finished
+  #     transmitting
+  attr_reader :send_end_ms
+
+  # @param [Number] milliseconds from {#time} until all the response HTTP
+  #     headers were received
+  attr_reader :receive_headers_end_ms
+
+  # @private use Event#for instead of calling this constructor directly
+  #
+  # @param [Hash<String, Number>] the raw RPC data for a ResourceTiming object
+  #     in the Network domain
+  def initialize(raw_timing)
+    @time = raw_timing['requestTime'].to_f
+
+    @connect_start_ms = raw_timing['connectStart'].to_f
+    @connect_end_ms = raw_timing['connectEnd'].to_f
+    @dns_start_ms = raw_timing['dnsStart'].to_f
+    @dns_end_ms = raw_timing['dnsEnd'].to_f
+    @proxy_start_ms = raw_timing['proxyStart'].to_f
+    @proxy_end_ms = raw_timing['proxyEnd'].to_f
+    @receive_headers_end_ms = raw_timing['receiveHeadersEnd'].to_f
+    @send_start_ms = raw_timing['sendStart'].to_f
+    @send_end_ms = raw_timing['sendEnd'].to_f
+    @ssl_start_ms = raw_timing['sslStart'].to_f
+    @ssl_end_ms = raw_timing['sslEnd'].to_f
+  end
+end  # class WebkitRemote::Client::NetworkResourceTiming
+
+# Wraps information about the reason behind a network request.
+class NetworkRequestInitiator
+  # @return [Symbol] reason behind the request; documented values are :parser,
+  #     :script and :other
+  attr_reader :type
+
+  # @return [String] URL of the document that references the requested resource
+  attr_reader :url
+
+  # @return [Number] number of the line that references the requested resource
+  attr_reader :line
+
+  # @return [WebkitRemote::Console
+  attr_reader :stack_trace
+
+  # @private Use Event#for instead of calling this constructor directly
+  def initialize(raw_initiator)
+    if raw_initiator['lineNumber']
+      @line = raw_initiator['lineNumber'].to_i
+    else
+      @line = nil
+    end
+    @stack_trace = WebkitRemote::Event::ConsoleMessage.parse_stack_trace(
+        raw_initiator['stackTrace'])
+    @type = (raw_initiator['type'] || 'other').to_sym
+    @url = raw_initiator['url']
+  end
+end  # class WebkitRemote::Client::NetworkRequestInitiator
+
+
+# Wraps information about a resource served out of the browser's cache.
+class NetworkCacheEntry
+  # @return [Symbol] the type of resource returned by this response; documented
+  #     values are :document, :font, :image, :other, :script, :stylesheet,
+  #     :websocket and :xhr
+  attr_reader :type
+
+  # @return [String] the URL of the response
+  attr_reader :url
+
+  # @return [WebkitRemote::Client::NetworkResponse] the cached response data
+  attr_reader :response
+
+  # @private Use Event#for instead of calling this constructor directly
+  def initialize(raw_cached_resource)
+    if raw_cached_resource['response']
+      @response = WebkitRemote::Client::NetworkResponse.new(
+          raw_cached_resource['response'])
+    else
+      @response = nil
+    end
+    @type = (raw_cached_resource['type'] || 'other').downcase.to_sym
+    @url = raw_cached_resource['url']
+  end
+end  # namespace WebkitRemote::Client::NetworkCacheEntry
+
+end  # namespace WebkitRemote::Client
+
+end  # namepspace WebkitRemote