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

net/http/http_transaction_unittest.cc

 // 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.
 
 #include "net/http/http_transaction_unittest.h"
 
 #include <algorithm>
 
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
@@ skipping 194 matching lines @@
       break;
     case READING:
       DidRead(result);
       break;
     default:
       NOTREACHED();
   }
 }
 
 
-MockNetworkTransaction::MockNetworkTransaction() :
-    ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)), data_cursor_(0) {
+MockNetworkTransaction::MockNetworkTransaction(MockNetworkLayer* factory)
+    : ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
+      data_cursor_(0),
+      transaction_factory_(factory->AsWeakPtr()) {
 }
 
 MockNetworkTransaction::~MockNetworkTransaction() {}
 
 int MockNetworkTransaction::Start(const net::HttpRequestInfo* request,
                                   net::CompletionCallback* callback,
                                   const net::BoundNetLog& net_log) {
   const MockTransaction* t = FindMockTransaction(request->url);
   if (!t)
     return net::ERR_FAILED;
@@ skipping 61 matching lines @@
   }
   if (test_mode_ & TEST_MODE_SYNC_NET_READ)
     return num;
 
   CallbackLater(callback, num);
   return net::ERR_IO_PENDING;
 }
 
 void MockNetworkTransaction::StopCaching() {}
 
+void MockNetworkTransaction::DoneReading() {
+  if (transaction_factory_)
+    transaction_factory_->TransactionDoneReading();
+}
+
 const net::HttpResponseInfo* MockNetworkTransaction::GetResponseInfo() const {
   return &response_;
 }
 
 net::LoadState MockNetworkTransaction::GetLoadState() const {
   if (data_cursor_)
     return net::LOAD_STATE_READING_RESPONSE;
   return net::LOAD_STATE_IDLE;
 }
 
 uint64 MockNetworkTransaction::GetUploadProgress() const {
   return 0;
 }
 
 void MockNetworkTransaction::CallbackLater(net::CompletionCallback* callback,
                                            int result) {
   MessageLoop::current()->PostTask(FROM_HERE, task_factory_.NewRunnableMethod(
       &MockNetworkTransaction::RunCallback, callback, result));
 }
 
 void MockNetworkTransaction::RunCallback(net::CompletionCallback* callback,
                                          int result) {
   callback->Run(result);
 }
 
-MockNetworkLayer::MockNetworkLayer() : transaction_count_(0) {}
+MockNetworkLayer::MockNetworkLayer()
+    : transaction_count_(0), done_reading_called_(false) {}
 
 MockNetworkLayer::~MockNetworkLayer() {}
 
+void MockNetworkLayer::TransactionDoneReading() {
+  done_reading_called_ = true;
+}
+
 int MockNetworkLayer::CreateTransaction(
     scoped_ptr<net::HttpTransaction>* trans) {
   transaction_count_++;
-  trans->reset(new MockNetworkTransaction());
+  trans->reset(new MockNetworkTransaction(this));
   return net::OK;
 }
 
 net::HttpCache* MockNetworkLayer::GetCache() {
   return NULL;
 }
 
 net::HttpNetworkSession* MockNetworkLayer::GetSession() {
   return NULL;
 }
@@ skipping 15 matching lines @@
     if (rv > 0) {
       content.append(buf->data(), rv);
     } else if (rv < 0) {
       return rv;
     }
   } while (rv > 0);
 
   result->swap(content);
   return net::OK;
 }