net: Notify the http job and cache transaction about a filter

net/http/http_transaction_unittest.h

 // Copyright (c) 2011 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_HTTP_HTTP_TRANSACTION_UNITTEST_H_
 #define NET_HTTP_HTTP_TRANSACTION_UNITTEST_H_
 #pragma once
 
 #include "net/http/http_transaction.h"
 
@@ skipping 129 matching lines @@
   std::string content_;
   scoped_refptr<net::IOBuffer> read_buf_;
   int error_;
 
   static int quit_counter_;
 };
 
 //-----------------------------------------------------------------------------
 // mock network layer
 
+class MockNetworkLayer;
+
 // This transaction class inspects the available set of mock transactions to
 // find data for the request URL.  It supports IO operations that complete
 // synchronously or asynchronously to help exercise different code paths in the
 // HttpCache implementation.
 class MockNetworkTransaction : public net::HttpTransaction {
  public:
-  MockNetworkTransaction();
+  explicit MockNetworkTransaction(MockNetworkLayer* factory);
   virtual ~MockNetworkTransaction();
 
   virtual int Start(const net::HttpRequestInfo* request,
                     net::CompletionCallback* callback,
                     const net::BoundNetLog& net_log);
 
   virtual int RestartIgnoringLastError(net::CompletionCallback* callback);
 
   virtual int RestartWithCertificate(net::X509Certificate* client_cert,
                                      net::CompletionCallback* callback);
 
   virtual int RestartWithAuth(const string16& username,
                               const string16& password,
                               net::CompletionCallback* callback);
 
   virtual bool IsReadyToRestartForAuth();
 
   virtual int Read(net::IOBuffer* buf, int buf_len,
                    net::CompletionCallback* callback);
 
   virtual void StopCaching();
 
+  virtual void DoneReading();
+
   virtual const net::HttpResponseInfo* GetResponseInfo() const;
 
   virtual net::LoadState GetLoadState() const;
 
   virtual uint64 GetUploadProgress() const;
 
  private:
   void CallbackLater(net::CompletionCallback* callback, int result);
   void RunCallback(net::CompletionCallback* callback, int result);
 
   ScopedRunnableMethodFactory<MockNetworkTransaction> task_factory_;
   net::HttpResponseInfo response_;
   std::string data_;
   int data_cursor_;
   int test_mode_;
+  base::WeakPtr<MockNetworkLayer> transaction_factory_;
 };
 
-class MockNetworkLayer : public net::HttpTransactionFactory {
+class MockNetworkLayer : public net::HttpTransactionFactory,
+                         public base::SupportsWeakPtr<MockNetworkLayer> {
  public:
   MockNetworkLayer();
   virtual ~MockNetworkLayer();
 
   int transaction_count() const { return transaction_count_; }
+  bool done_reading_called() const { return done_reading_called_; }
+  void TransactionDoneReading();
 
   // net::HttpTransactionFactory:
   virtual int CreateTransaction(scoped_ptr<net::HttpTransaction>* trans);
   virtual net::HttpCache* GetCache();
   virtual net::HttpNetworkSession* GetSession();
 
  private:
   int transaction_count_;
+  bool done_reading_called_;
 };
 
 //-----------------------------------------------------------------------------
 // helpers
 
 // read the transaction completely
 int ReadTransaction(net::HttpTransaction* trans, std::string* result);
 
 #endif  // NET_HTTP_HTTP_TRANSACTION_UNITTEST_H_