Remove the HANDLED_EXTERNALLY status code.

content/common/resource_dispatcher_unittest.cc

 // 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.
 
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/process.h"
 #include "base/process_util.h"
 #include "content/common/request_extra_data.h"
 #include "content/common/resource_dispatcher.h"
 #include "content/common/resource_messages.h"
 #include "content/public/common/resource_response.h"
+#include "net/base/net_errors.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_response_headers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/appcache/appcache_interfaces.h"
 
 using webkit_glue::ResourceLoaderBridge;
 using webkit_glue::ResourceResponseInfo;
 
 namespace content {
 
@@ skipping 35 matching lines @@
 
   virtual void OnReceivedData(const char* data,
                               int data_length,
                               int encoded_data_length) OVERRIDE {
     EXPECT_FALSE(complete_);
     data_.append(data, data_length);
     total_encoded_data_length_ += encoded_data_length;
   }
 
   virtual void OnCompletedRequest(
-      const net::URLRequestStatus& status,
+      int error_code,
+      bool was_ignored_by_handler,
       const std::string& security_info,
-      const base::TimeTicks& completion_time) OVERRIDE {
+      const base::TimeTicks& completion_time) {
     EXPECT_FALSE(complete_);
     complete_ = true;
   }
 
   bool complete() const {
     return complete_;
   }
   const std::string& data() const {
     return data_;
   }
@@ skipping 155 matching lines @@
 
   virtual bool Send(IPC::Message* msg) OVERRIDE {
     delete msg;
     return true;
   }
 
   void InitMessages() {
     set_defer_loading(true);
 
     ResourceResponseHead response_head;
-    response_head.status.set_status(net::URLRequestStatus::SUCCESS);
+    response_head.error_code = net::OK;
 
     dispatcher_->OnMessageReceived(
         ResourceMsg_ReceivedResponse(0, 0, response_head));
 
     // Duplicate the shared memory handle so both the test and the callee can
     // close their copy.
     base::SharedMemoryHandle duplicated_handle;
     EXPECT_TRUE(shared_handle_.ShareToProcess(base::GetCurrentProcessHandle(),
                                               &duplicated_handle));
 
@@ skipping 25 matching lines @@
   }
 
   virtual void OnReceivedData(const char* data,
                               int data_length,
                               int encoded_data_length) OVERRIDE {
     EXPECT_EQ(defer_loading_, false);
     set_defer_loading(false);
   }
 
   virtual void OnCompletedRequest(
-      const net::URLRequestStatus& status,
+      int error_code,
+      bool was_ignored_by_handler,
       const std::string& security_info,
-      const base::TimeTicks& completion_time) OVERRIDE {
+      const base::TimeTicks& completion_time) {
   }
 
  protected:
   virtual void SetUp() OVERRIDE {
     ResourceDispatcherTest::SetUp();
     shared_handle_.Delete(kShmemSegmentName);
     EXPECT_TRUE(shared_handle_.CreateNamed(kShmemSegmentName, false, 100));
   }
 
   virtual void TearDown() OVERRIDE {
@@ skipping 63 matching lines @@
 
   virtual void OnDownloadedData(int len) OVERRIDE {
   }
 
   virtual void OnReceivedData(const char* data,
                               int data_length,
                               int encoded_data_length) OVERRIDE {
   }
 
   virtual void OnCompletedRequest(
-      const net::URLRequestStatus& status,
+      int error_code,
+      bool was_ignored_by_handler,
       const std::string& security_info,
       const base::TimeTicks& completion_time) OVERRIDE {
   }
 
   const ResourceResponseInfo& response_info() const { return response_info_; }
 
  private:
   ResourceResponseInfo response_info_;
 };
 
 // TODO(simonjam): Enable this when 10829031 lands.
 TEST_F(TimeConversionTest, DISABLED_ProperlyInitialized) {
   ResourceResponseHead response_head;
-  response_head.status.set_status(net::URLRequestStatus::SUCCESS);
+  response_head.error_code = net::OK;
   response_head.request_start = base::TimeTicks::FromInternalValue(5);
   response_head.response_start = base::TimeTicks::FromInternalValue(15);
   response_head.load_timing.base_time = base::Time::Now();
   response_head.load_timing.base_ticks = base::TimeTicks::FromInternalValue(10);
   response_head.load_timing.dns_start = -1;
   response_head.load_timing.connect_start = 3;
 
   PerformTest(response_head);
 
   EXPECT_LT(0, response_info().load_timing.base_ticks.ToInternalValue());
   EXPECT_EQ(-1, response_info().load_timing.dns_start);
   EXPECT_LE(0, response_info().load_timing.connect_start);
 }
 
 TEST_F(TimeConversionTest, PartiallyInitialized) {
   ResourceResponseHead response_head;
-  response_head.status.set_status(net::URLRequestStatus::SUCCESS);
+  response_head.error_code = net::OK;
   response_head.request_start = base::TimeTicks::FromInternalValue(5);
   response_head.response_start = base::TimeTicks::FromInternalValue(15);
 
   PerformTest(response_head);
 
   EXPECT_EQ(0, response_info().load_timing.base_ticks.ToInternalValue());
   EXPECT_EQ(-1, response_info().load_timing.dns_start);
 }
 
 TEST_F(TimeConversionTest, NotInitialized) {
   ResourceResponseHead response_head;
-  response_head.status.set_status(net::URLRequestStatus::SUCCESS);
+  response_head.error_code = net::OK;
 
   PerformTest(response_head);
 
   EXPECT_EQ(0, response_info().load_timing.base_ticks.ToInternalValue());
   EXPECT_EQ(-1, response_info().load_timing.dns_start);
 }
 
 }  // namespace content