Add --headless flag to Windows

headless/public/util/generic_url_request_job.h

 // Copyright 2016 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 HEADLESS_PUBLIC_UTIL_GENERIC_URL_REQUEST_JOB_H_
 #define HEADLESS_PUBLIC_UTIL_GENERIC_URL_REQUEST_JOB_H_
 
 #include <stddef.h>
 #include <functional>
 #include <memory>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
+#include "headless/public/headless_export.h"
 #include "headless/public/util/managed_dispatch_url_request_job.h"
 #include "headless/public/util/url_fetcher.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request.h"
 #include "url/gurl.h"
 
 namespace net {
 class HttpResponseHeaders;
 class IOBuffer;
 }  // namespace net
 
 namespace content {
 class ResourceRequestInfo;
 }  // namespace content
 
 namespace headless {
 
 class HeadlessBrowserContext;
 class URLRequestDispatcher;
 
 // Wrapper around net::URLRequest with helpers to access select metadata.
-class Request {
+class HEADLESS_EXPORT Request {
  public:
   virtual uint64_t GetRequestId() const = 0;
 
   virtual const net::URLRequest* GetURLRequest() const = 0;
 
   // The frame from which the request came from.
   virtual int GetFrameTreeNodeId() const = 0;
 
   // The devtools agent host id for the page where the request came from.
   virtual std::string GetDevToolsAgentHostId() const = 0;
@@ skipping 28 matching lines @@
  protected:
   Request() {}
   virtual ~Request() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Request);
 };
 
 // Details of a pending request received by GenericURLRequestJob which must be
 // either Allowed, Blocked, Modified or have it's response Mocked.
-class PendingRequest {
+class HEADLESS_EXPORT PendingRequest {
  public:
   virtual const Request* GetRequest() const = 0;
 
   // Allows the request to proceed as normal.
   virtual void AllowRequest() = 0;
 
   // Causes the request to fail with the specified |error|.
   virtual void BlockRequest(net::Error error) = 0;
 
   // Allows the request to be completely re-written.
@@ skipping 24 matching lines @@
 //
 // 1. The delegate can extension observe / cancel and redirect requests
 // 2. The delegate can optionally provide the results, otherwise the specifed
 //    fetcher is invoked.
 class HEADLESS_EXPORT GenericURLRequestJob
     : public ManagedDispatchURLRequestJob,
       public URLFetcher::ResultListener,
       public PendingRequest,
       public Request {
  public:
-  class Delegate {
+  class HEADLESS_EXPORT Delegate {
    public:
     // Notifies the delegate of an PendingRequest which must either be
     // allowed, blocked, modifed or it's response mocked. Called on an arbitrary
     // thread.
     virtual void OnPendingRequest(PendingRequest* pending_request) = 0;
 
     // Notifies the delegate of any fetch failure. Called on an arbitrary
     // thread.
     virtual void OnResourceLoadFailed(const Request* request,
                                       net::Error error) = 0;
@@ skipping 81 matching lines @@
   static uint64_t next_request_id_;
 
   base::WeakPtrFactory<GenericURLRequestJob> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GenericURLRequestJob);
 };
 
 }  // namespace headless
 
 #endif  // HEADLESS_PUBLIC_UTIL_GENERIC_URL_REQUEST_JOB_H_