Getting rid of net::LOAD_ENABLE_LOAD_TIMING

content/browser/loader/resource_request_info_impl.h

 // Copyright (c) 2012 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.
 
 #ifndef CONTENT_BROWSER_LOADER_RESOURCE_REQUEST_INFO_IMPL_H_
 #define CONTENT_BROWSER_LOADER_RESOURCE_REQUEST_INFO_IMPL_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 38 matching lines @@
       bool is_main_frame,
       bool parent_is_main_frame,
       int parent_render_frame_id,
       ResourceType resource_type,
       PageTransition transition_type,
       bool should_replace_current_entry,
       bool is_download,
       bool is_stream,
       bool allow_download,
       bool has_user_gesture,
+      bool enable_load_timing,
       blink::WebReferrerPolicy referrer_policy,
       blink::WebPageVisibilityState visibility_state,
       ResourceContext* context,
       base::WeakPtr<ResourceMessageFilter> filter,
       bool is_async);
   virtual ~ResourceRequestInfoImpl();
 
   // ResourceRequestInfo implementation:
   virtual ResourceContext* GetContext() const OVERRIDE;
   virtual int GetChildID() const OVERRIDE;
@@ skipping 76 matching lines @@
 
   void set_was_ignored_by_handler(bool value) {
     was_ignored_by_handler_ = value;
   }
 
   // The approximate in-memory size (bytes) that we credited this request
   // as consuming in |outstanding_requests_memory_cost_map_|.
   int memory_cost() const { return memory_cost_; }
   void set_memory_cost(int cost) { memory_cost_ = cost; }
 
+  bool is_load_timing_enabled() const { return enable_load_timing_; }
+
  private:
   FRIEND_TEST_ALL_PREFIXES(ResourceDispatcherHostTest,
                            DeletedFilterDetached);
   FRIEND_TEST_ALL_PREFIXES(ResourceDispatcherHostTest,
                            DeletedFilterDetachedRedirect);
   // Non-owning, may be NULL.
   CrossSiteResourceHandler* cross_site_handler_;
   DetachableResourceHandler* detachable_handler_;
 
   int process_type_;
   int child_id_;
   int route_id_;
   int origin_pid_;
   int request_id_;
   int render_frame_id_;
   bool is_main_frame_;
   bool parent_is_main_frame_;
   int parent_render_frame_id_;
   bool should_replace_current_entry_;
   bool is_download_;
   bool is_stream_;
   bool allow_download_;
   bool has_user_gesture_;
+  bool enable_load_timing_;

[mmenke, 2014/08/07 14:40:55]

Did you do any thinking about whether we even need this field, or can just send
load timing information to the other process unconditionally?  It used to be
that load timing information was collected by monitoring NetLog, so devtool
would have to watch for events and then collect events for each request, and
assemble them to construct load timing information, so there was extra overhead
to gathering the information.

The network stack now gathers that information for all requests, so there's
basically no extra overhead if we always send that information to the renderer.

The two questions here are:
1)  Does this open up any timing attacks / security / privacy issues we care
about.
2)  Does providing that information to request that don't expect it expose any
bugs.

The answer for now may just be "Add a TODO to think about this".

   bool was_ignored_by_handler_;
   ResourceType resource_type_;
   PageTransition transition_type_;
   int memory_cost_;
   blink::WebReferrerPolicy referrer_policy_;
   blink::WebPageVisibilityState visibility_state_;
   ResourceContext* context_;
   // The filter might be deleted without deleting this object if the process
   // exits during a transfer.
   base::WeakPtr<ResourceMessageFilter> filter_;
   bool is_async_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceRequestInfoImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_LOADER_RESOURCE_REQUEST_INFO_IMPL_H_