Clean up Automation and Chrome Frame IPC code.

chrome/browser/automation/url_request_automation_job.cc

 // Copyright (c) 2010 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 "chrome/browser/automation/url_request_automation_job.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "chrome/browser/automation/automation_resource_message_filter.h"
@@ skipping 130 matching lines @@
     // If this is a pending job, then register it immediately with the message
     // filter so it can be serviced later when we receive a request from the
     // external host to connect to the corresponding external tab.
     message_filter_->RegisterRequest(this);
   }
 }
 
 void URLRequestAutomationJob::Kill() {
   if (message_filter_.get()) {
     if (!is_pending()) {
-      message_filter_->Send(new AutomationMsg_RequestEnd(0, tab_, id_,
+      message_filter_->Send(new AutomationMsg_RequestEnd(tab_, id_,
           URLRequestStatus(URLRequestStatus::CANCELED, net::ERR_ABORTED)));
     }
   }
   DisconnectFromMessageFilter();
   net::URLRequestJob::Kill();
 }
 
 bool URLRequestAutomationJob::ReadRawData(
     net::IOBuffer* buf, int buf_size, int* bytes_read) {
   DVLOG(1) << "URLRequestAutomationJob: " << request_->url().spec()
            << " - read pending: " << buf_size;
 
   // We should not receive a read request for a pending job.
   DCHECK(!is_pending());
 
   pending_buf_ = buf;
   pending_buf_size_ = buf_size;
 
   if (message_filter_) {
-    message_filter_->Send(new AutomationMsg_RequestRead(0, tab_, id_,
-        buf_size));
+    message_filter_->Send(new AutomationMsg_RequestRead(tab_, id_, buf_size));
     SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
   } else {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         method_factory_.NewRunnableMethod(
             &URLRequestAutomationJob::NotifyJobCompletionTask));
   }
   return false;
 }
 
@@ skipping 51 matching lines @@
   return true;
 }
 
 bool URLRequestAutomationJob::MayFilterMessage(const IPC::Message& message,
                                                int* request_id) {
   switch (message.type()) {
     case AutomationMsg_RequestStarted::ID:
     case AutomationMsg_RequestData::ID:
     case AutomationMsg_RequestEnd::ID: {
       void* iter = NULL;
-      int tab = 0;
-      if (message.ReadInt(&iter, &tab) &&
-          message.ReadInt(&iter, request_id)) {
+      if (message.ReadInt(&iter, request_id))
         return true;
-      }
       break;
     }
   }
 
   return false;
 }
 
 void URLRequestAutomationJob::OnMessage(const IPC::Message& message) {
   if (!request_) {
     NOTREACHED() << __FUNCTION__
                  << ": Unexpected request received for job:"
                  << id();
     return;
   }
 
   IPC_BEGIN_MESSAGE_MAP(URLRequestAutomationJob, message)
     IPC_MESSAGE_HANDLER(AutomationMsg_RequestStarted, OnRequestStarted)
     IPC_MESSAGE_HANDLER(AutomationMsg_RequestData, OnDataAvailable)
     IPC_MESSAGE_HANDLER(AutomationMsg_RequestEnd, OnRequestEnd)
   IPC_END_MESSAGE_MAP()
 }
 
-void URLRequestAutomationJob::OnRequestStarted(int tab, int id,
-    const IPC::AutomationURLResponse& response) {
+void URLRequestAutomationJob::OnRequestStarted(
+    int id, const AutomationURLResponse& response) {
   DVLOG(1) << "URLRequestAutomationJob: " << request_->url().spec()
            << " - response started.";
   set_expected_content_size(response.content_length);
   mime_type_ = response.mime_type;
 
   redirect_url_ = response.redirect_url;
   redirect_status_ = response.redirect_status;
   DCHECK(redirect_status_ == 0 || redirect_status_ == 200 ||
          (redirect_status_ >= 300 && redirect_status_ < 400));
 
   if (!response.headers.empty()) {
     headers_ = new net::HttpResponseHeaders(
         net::HttpUtil::AssembleRawHeaders(response.headers.data(),
                                           response.headers.size()));
   }
   NotifyHeadersComplete();
 }
 
 void URLRequestAutomationJob::OnDataAvailable(
-    int tab, int id, const std::string& bytes) {
+    int id, const std::string& bytes) {
   DVLOG(1) << "URLRequestAutomationJob: " << request_->url().spec()
            << " - data available, Size: " << bytes.size();
   DCHECK(!bytes.empty());
 
   // The request completed, and we have all the data.
   // Clear any IO pending status.
   SetStatus(URLRequestStatus());
 
   if (pending_buf_ && pending_buf_->data()) {
     DCHECK_GE(pending_buf_size_, bytes.size());
     const int bytes_to_copy = std::min(bytes.size(), pending_buf_size_);
     memcpy(pending_buf_->data(), &bytes[0], bytes_to_copy);
 
     pending_buf_ = NULL;
     pending_buf_size_ = 0;
 
     NotifyReadComplete(bytes_to_copy);
   } else {
     NOTREACHED() << "Received unexpected data of length:" << bytes.size();
   }
 }
 
 void URLRequestAutomationJob::OnRequestEnd(
-    int tab, int id, const URLRequestStatus& status) {
+    int id, const URLRequestStatus& status) {
 #ifndef NDEBUG
   std::string url;
   if (request_)
     url = request_->url().spec();
   DVLOG(1) << "URLRequestAutomationJob: " << url << " - request end. Status: "
            << status.status();
 #endif
 
   // TODO(tommi): When we hit certificate errors, notify the delegate via
   // OnSSLCertificateError().  Right now we don't have the certificate
@@ skipping 102 matching lines @@
 
   // Get the resource type (main_frame/script/image/stylesheet etc.
   ResourceDispatcherHostRequestInfo* request_info =
       ResourceDispatcherHost::InfoForRequest(request_);
   ResourceType::Type resource_type = ResourceType::MAIN_FRAME;
   if (request_info) {
     resource_type = request_info->resource_type();
   }
 
   // Ask automation to start this request.
-  IPC::AutomationURLRequest automation_request(
+  AutomationURLRequest automation_request(
       request_->url().spec(),
       request_->method(),
       referrer.spec(),
       new_request_headers.ToString(),
       request_->get_upload(),
       resource_type,
       request_->load_flags());
 
   DCHECK(message_filter_);
-  message_filter_->Send(new AutomationMsg_RequestStart(0, tab_, id_,
-      automation_request));
+  message_filter_->Send(new AutomationMsg_RequestStart(
+      tab_, id_, automation_request));
 }
 
 void URLRequestAutomationJob::DisconnectFromMessageFilter() {
   if (message_filter_) {
     message_filter_->UnRegisterRequest(this);
     message_filter_ = NULL;
   }
 }
 
 void URLRequestAutomationJob::StartPendingJob(
@@ skipping 10 matching lines @@
   if (!is_done()) {
     NotifyDone(request_status_);
   }
   // Reset any pending reads.
   if (pending_buf_) {
     pending_buf_ = NULL;
     pending_buf_size_ = 0;
     NotifyReadComplete(0);
   }
 }