[ON HOLD] Implement pull-based design for content decoding

net/url_request/url_request_http_job.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 NET_URL_REQUEST_URL_REQUEST_HTTP_JOB_H_
 #define NET_URL_REQUEST_URL_REQUEST_HTTP_JOB_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "net/base/auth.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_error_details.h"
 #include "net/base/net_export.h"
 #include "net/base/sdch_manager.h"
 #include "net/cookies/cookie_store.h"
-#include "net/filter/filter.h"
+#include "net/filter/sdch_policy_delegate.h"
 #include "net/http/http_request_info.h"
 #include "net/socket/connection_attempts.h"
 #include "net/url_request/url_request_backoff_manager.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_throttler_entry_interface.h"
 
 namespace net {
 
 class HttpRequestHeaders;
 class HttpResponseHeaders;
@@ skipping 18 matching lines @@
                     NetworkDelegate* network_delegate,
                     const HttpUserAgentSettings* http_user_agent_settings);
 
   ~URLRequestHttpJob() override;
 
   // Overridden from URLRequestJob:
   void SetPriority(RequestPriority priority) override;
   void Start() override;
   void Kill() override;
   void GetConnectionAttempts(ConnectionAttempts* out) const override;
+  std::unique_ptr<SourceStream> SetUpSourceStream() override;
 
   RequestPriority priority() const {
     return priority_;
   }
 
  private:
   enum CompletionCause {
     ABORTED,
     FINISHED
   };
 
   typedef base::RefCountedData<bool> SharedBoolean;
 
-  class HttpFilterContext;
+  class SdchContext;
 
   // Shadows URLRequestJob's version of this method.
   void NotifyBeforeNetworkStart(bool* defer);
 
   // Shadows URLRequestJob's version of this method so we can grab cookies.
   void NotifyHeadersComplete();
 
   void DestroyTransaction();
 
   void AddExtraHeaders();
@@ skipping 30 matching lines @@
   void SetExtraRequestHeaders(const HttpRequestHeaders& headers) override;
   LoadState GetLoadState() const override;
   UploadProgress GetUploadProgress() const override;
   bool GetMimeType(std::string* mime_type) const override;
   bool GetCharset(std::string* charset) override;
   void GetResponseInfo(HttpResponseInfo* info) override;
   void GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const override;
   bool GetRemoteEndpoint(IPEndPoint* endpoint) const override;
   int GetResponseCode() const override;
   void PopulateNetErrorDetails(NetErrorDetails* details) const override;
-  std::unique_ptr<Filter> SetupFilter() const override;
   bool CopyFragmentOnRedirect(const GURL& location) const override;
   bool IsSafeRedirect(const GURL& location) override;
   bool NeedsAuth() override;
   void GetAuthChallengeInfo(scoped_refptr<AuthChallengeInfo>*) override;
   void SetAuth(const AuthCredentials& credentials) override;
   void CancelAuth() override;
   void ContinueWithCertificate(X509Certificate* client_cert,
                                SSLPrivateKey* client_private_key) override;
   void ContinueDespiteLastError() override;
   void ResumeNetworkStart() override;
   int ReadRawData(IOBuffer* buf, int buf_size) override;
   void StopCaching() override;
   bool GetFullRequestHeaders(HttpRequestHeaders* headers) const override;
   int64_t GetTotalReceivedBytes() const override;
   int64_t GetTotalSentBytes() const override;
   void DoneReading() override;
   void DoneReadingRedirectResponse() override;
 
   HostPortPair GetSocketAddress() const override;
   void NotifyURLRequestDestroyed() override;
 
   void RecordTimer();
   void ResetTimer();
 
   void UpdatePacketReadTimes() override;
-  void RecordPacketStats(FilterContext::StatisticSelector statistic) const;
+  void RecordPacketStats(
+      SdchPolicyDelegate::Context::StatisticSelector statistic) const;
 
   // Starts the transaction if extensions using the webrequest API do not
   // object.
   void StartTransaction();
   // If |result| is OK, calls StartTransactionInternal. Otherwise notifies
   // cancellation.
   void MaybeStartTransactionInternal(int result);
   void StartTransactionInternal();
 
   void RecordPerfHistograms(CompletionCause reason);
@@ skipping 74 matching lines @@
   // Since we don't save all packet times in packet_times_, we save the
   // last time for use in histograms.
   base::Time final_packet_time_;
 
   // The start time for the job, ignoring re-starts.
   base::TimeTicks start_time_;
 
   // When the transaction finished reading the request headers.
   base::TimeTicks receive_headers_end_;
 
-  std::unique_ptr<HttpFilterContext> filter_context_;
+  std::unique_ptr<SdchPolicyDelegate> sdch_delegate_;
 
   CompletionCallback on_headers_received_callback_;
 
   // We allow the network delegate to modify a copy of the response headers.
   // This prevents modifications of headers that are shared with the underlying
   // layers of the network stack.
   scoped_refptr<HttpResponseHeaders> override_response_headers_;
 
   // The network delegate can mark a URL as safe for redirection.
   // The reference fragment of the original URL is not appended to the redirect
@@ skipping 19 matching lines @@
   int64_t total_sent_bytes_from_previous_transactions_;
 
   base::WeakPtrFactory<URLRequestHttpJob> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestHttpJob);
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_HTTP_JOB_H_