Remove unused ATL headers.

chrome/renderer/webplugin_delegate_proxy.cc

 // Copyright (c) 2006-2008 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/renderer/webplugin_delegate_proxy.h"
 
-#include "build/build_config.h"
-
-#if defined(OS_WIN)
-#include <atlbase.h>
-#endif
+#include <algorithm>
 
 #include "app/gfx/canvas.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
+#include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/ref_counted.h"
 #include "base/string_util.h"
 #include "base/gfx/blit.h"
 #include "base/gfx/size.h"
 #include "base/gfx/native_widget_types.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/plugin_messages.h"
 #include "chrome/common/render_messages.h"
@@ skipping 84 matching lines @@
     params.last_modified = last_modified;
     params.request_is_seekable = request_is_seekable;
     // Grab a reference on the underlying channel so it does not get
     // deleted from under us.
     scoped_refptr<PluginChannelHost> channel_ref(channel_);
     channel_->Send(new PluginMsg_DidReceiveResponse(instance_id_, params));
   }
 
   void DidReceiveData(const char* buffer, int length, int data_offset) {
     DCHECK(channel_ != NULL);
-    DCHECK(length > 0);
+    DCHECK_GT(length, 0);
     std::vector<char> data;
     data.resize(static_cast<size_t>(length));
     memcpy(&data.front(), buffer, length);
     // Grab a reference on the underlying channel so it does not get
     // deleted from under us.
     scoped_refptr<PluginChannelHost> channel_ref(channel_);
     channel_->Send(new PluginMsg_DidReceiveData(instance_id_, resource_id_,
                                                 data, data_offset));
   }
 
@@ skipping 78 matching lines @@
     // association on POSIX, and if we ask for a new connection before it is
     // released, the plugin will give us a new FD, and we'll assert when trying
     // to associate it with the channel name.
     channel_host_ = NULL;
   }
 
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 bool WebPluginDelegateProxy::Initialize(const GURL& url,
-                                        const std::vector<std::string>& arg_names,
-                                        const std::vector<std::string>& arg_values,
-                                        webkit_glue::WebPlugin* plugin,
-                                        bool load_manually) {
+    const std::vector<std::string>& arg_names,
+    const std::vector<std::string>& arg_values,
+    webkit_glue::WebPlugin* plugin,
+    bool load_manually) {
   IPC::ChannelHandle channel_handle;
   WebPluginInfo info;
   if (!RenderThread::current()->Send(new ViewHostMsg_OpenChannelToPlugin(
           url, mime_type_, webkit_glue::GetWebKitLocale(),
           &channel_handle, &info))) {
     return false;
   }
 
 #if defined(OS_POSIX)
   if (channel_handle.name.empty()) {
@@ skipping 83 matching lines @@
   params.id = 0;
   params.mime_type = mime_type;
   params.headers = headers;
   params.expected_length = expected_length;
   params.last_modified = last_modified;
   Send(new PluginMsg_DidReceiveManualResponse(instance_id_, url, params));
 }
 
 void WebPluginDelegateProxy::DidReceiveManualData(const char* buffer,
                                                   int length) {
-  DCHECK(length > 0);
+  DCHECK_GT(length, 0);
   std::vector<char> data;
   data.resize(static_cast<size_t>(length));
   memcpy(&data.front(), buffer, length);
   Send(new PluginMsg_DidReceiveManualData(instance_id_, data));
 }
 
 void WebPluginDelegateProxy::DidFinishManualLoading() {
   Send(new PluginMsg_DidFinishManualLoading(instance_id_));
 }
 
@@ skipping 92 matching lines @@
   if (bitmaps_changed)
 #endif
   {
     if (transport_store_.get()) {
       param.windowless_buffer = transport_store_->handle();
     } else if (background_store_.get()) {
       param.background_buffer = background_store_->handle();
     }
   }
 
- IPC::Message* msg;
+  IPC::Message* msg;
 #if defined (OS_WIN)
   std::wstring filename = StringToLowerASCII(info_.path.BaseName().value());
   if (info_.name.find(L"Windows Media Player") != std::wstring::npos) {
     // Need to update geometry synchronously with WMP, otherwise if a site
     // scripts the plugin to start playing while it's in the middle of handling
     // an update geometry message, videos don't play.  See urls in bug 20260.
     msg = new PluginMsg_UpdateGeometrySync(instance_id_, param);
   } else
 #endif
   {
@@ skipping 617 matching lines @@
     intptr_t existing_stream, bool notify_needed, intptr_t notify_data) {
   plugin_->InitiateHTTPRangeRequest(url.c_str(), range_info.c_str(),
                                     existing_stream, notify_needed,
                                     notify_data);
 }
 
 void WebPluginDelegateProxy::OnDeferResourceLoading(int resource_id,
                                                     bool defer) {
   plugin_->SetDeferResourceLoading(resource_id, defer);
 }