path: root/patches/chromium/0003-Clang-libc-does-not-support-incomplete-types-in-temp.patch

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Zeno Albisser <zeno.albisser@digia.com>
Date: Thu, 27 Jun 2013 15:58:32 +0200
Subject: Clang / libc++ does not support incomplete types in templates. See:
 http://clang.llvm.org/compatibility.html#undep_incomplete

Therefore forward declarations must be removed in several places:
- AudioBus::QueuedAudioBuffer
- base::Callback
- GURL
- HttpAuthCache::Entry
- ImageFamily::MapKey
- MediaStreamDispatcher::Request
- MediaStreamDispatcher::Stream
- MediaStreamDispatcherHost::StreamRequest
- MessagePortService::MessagePort
- MockCertVerifier::Rule
- PepperRendererInstanceData
- RuleBasedHostResolverProc::Rule
- WebURLError
- WebURLLoaderMockFactory::ResponseInfo
- WorkerDevToolsManager::InspectedWorker
- WorkerDevToolsManager::TerminatedInspectedWorker
---
 base/callback_forward.h                            |  9 +-----
 .../browser/devtools/worker_devtools_manager.cc    | 26 ------------------
 content/browser/devtools/worker_devtools_manager.h | 26 ++++++++++++++++--
 content/browser/message_port_service.cc            | 22 ---------------
 content/browser/message_port_service.h             | 23 +++++++++++++++-
 content/common/gpu/gpu_messages.h                  |  4 ++-
 content/renderer/media/media_stream_dispatcher.cc  | 31 ---------------------
 content/renderer/media/media_stream_dispatcher.h   | 31 +++++++++++++++++++--
 content/renderer/pepper/message_channel.cc         | 12 --------
 content/renderer/pepper/message_channel.h          | 18 ++++++++----
 gpu/config/dx_diag_node.cc                         |  4 +++
 gpu/config/dx_diag_node.h                          |  6 ++++
 media/filters/ffmpeg_audio_decoder.cc              |  6 ----
 media/filters/ffmpeg_audio_decoder.h               |  7 ++++-
 net/cert/mock_cert_verifier.cc                     | 19 -------------
 net/cert/mock_cert_verifier.h                      | 20 +++++++++++++-
 net/dns/mock_host_resolver.cc                      | 31 ---------------------
 net/dns/mock_host_resolver.h                       | 32 +++++++++++++++++++++-
 18 files changed, 158 insertions(+), 169 deletions(-)

diff --git a/base/callback_forward.h b/base/callback_forward.h
index 7983248..8538bb2 100644
--- a/base/callback_forward.h
+++ b/base/callback_forward.h
@@ -5,13 +5,6 @@
 #ifndef BASE_CALLBACK_FORWARD_H_
 #define BASE_CALLBACK_FORWARD_H_
 
-namespace base {
-
-template <typename Sig>
-class Callback;
-
-typedef Callback<void(void)> Closure;
-
-}  // namespace base
+#include "base/callback.h"
 
 #endif  // BASE_CALLBACK_FORWARD_H
diff --git a/content/browser/devtools/worker_devtools_manager.cc b/content/browser/devtools/worker_devtools_manager.cc
index f060881..983c55c 100644
--- a/content/browser/devtools/worker_devtools_manager.cc
+++ b/content/browser/devtools/worker_devtools_manager.cc
@@ -51,19 +51,6 @@ base::LazyInstance<AgentHosts>::Leaky g_orphan_map = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
-struct WorkerDevToolsManager::TerminatedInspectedWorker {
-  TerminatedInspectedWorker(WorkerId id,
-                            const GURL& url,
-                            const base::string16& name)
-      : old_worker_id(id),
-        worker_url(url),
-        worker_name(name) {}
-  WorkerId old_worker_id;
-  GURL worker_url;
-  base::string16 worker_name;
-};
-
-
 class WorkerDevToolsManager::WorkerDevToolsAgentHost
     : public IPCDevToolsAgentHost {
  public:
@@ -202,19 +189,6 @@ class WorkerDevToolsManager::DetachedClientHosts {
   }
 };
 
-struct WorkerDevToolsManager::InspectedWorker {
-  InspectedWorker(WorkerProcessHost* host, int route_id, const GURL& url,
-                  const base::string16& name)
-      : host(host),
-        route_id(route_id),
-        worker_url(url),
-        worker_name(name) {}
-  WorkerProcessHost* const host;
-  int const route_id;
-  GURL worker_url;
-  base::string16 worker_name;
-};
-
 // static
 WorkerDevToolsManager* WorkerDevToolsManager::GetInstance() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
diff --git a/content/browser/devtools/worker_devtools_manager.h b/content/browser/devtools/worker_devtools_manager.h
index 8a9a708..955b1db 100644
--- a/content/browser/devtools/worker_devtools_manager.h
+++ b/content/browser/devtools/worker_devtools_manager.h
@@ -54,7 +54,20 @@ class WorkerDevToolsManager {
  private:
   friend struct DefaultSingletonTraits<WorkerDevToolsManager>;
   class DetachedClientHosts;
-  struct InspectedWorker;
+
+  struct InspectedWorker {
+    InspectedWorker(WorkerProcessHost* host, int route_id, const GURL& url,
+                    const base::string16& name)
+        : host(host),
+          route_id(route_id),
+          worker_url(url),
+          worker_name(name) {}
+    WorkerProcessHost* const host;
+    int const route_id;
+    GURL worker_url;
+    base::string16 worker_name;
+  };
+
   typedef std::list<InspectedWorker> InspectedWorkersList;
 
   WorkerDevToolsManager();
@@ -84,7 +97,16 @@ class WorkerDevToolsManager {
 
   InspectedWorkersList inspected_workers_;
 
-  struct TerminatedInspectedWorker;
+  struct TerminatedInspectedWorker {
+    TerminatedInspectedWorker(WorkerId id, const GURL& url, const base::string16& name)
+        : old_worker_id(id),
+          worker_url(url),
+          worker_name(name) {}
+    WorkerId old_worker_id;
+    GURL worker_url;
+    base::string16 worker_name;
+  };
+
   typedef std::list<TerminatedInspectedWorker> TerminatedInspectedWorkers;
   // List of terminated workers for which there may be a devtools client on
   // the UI thread. Worker entry is added into this list when inspected worker
diff --git a/content/browser/message_port_service.cc b/content/browser/message_port_service.cc
index 0d9f608..25c2b44 100644
--- a/content/browser/message_port_service.cc
+++ b/content/browser/message_port_service.cc
@@ -9,28 +9,6 @@
 
 namespace content {
 
-struct MessagePortService::MessagePort {
-  // |filter| and |route_id| are what we need to send messages to the port.
-  // |filter| is just a weak pointer since we get notified when its process has
-  // gone away and remove it.
-  MessagePortMessageFilter* filter;
-  int route_id;
-  // A globally unique id for this message port.
-  int message_port_id;
-  // The globally unique id of the entangled message port.
-  int entangled_message_port_id;
-  // If true, all messages to this message port are queued and not delivered.
-  // This is needed so that when a message port is sent between processes all
-  // pending message get transferred. There are two possibilities for pending
-  // messages: either they are already received by the child process, or they're
-  // in-flight. This flag ensures that the latter type get flushed through the
-  // system.
-  // This flag should only be set to true in response to
-  // MessagePortHostMsg_QueueMessages.
-  bool queue_messages;
-  QueuedMessages queued_messages;
-};
-
 MessagePortService* MessagePortService::GetInstance() {
   return Singleton<MessagePortService>::get();
 }
diff --git a/content/browser/message_port_service.h b/content/browser/message_port_service.h
index 6689591..3e197a4 100644
--- a/content/browser/message_port_service.h
+++ b/content/browser/message_port_service.h
@@ -64,7 +64,28 @@ class MessagePortService {
   // verify that the message port id exists.
   void Erase(int message_port_id);
 
-  struct MessagePort;
+  struct MessagePort {
+    // |filter| and |route_id| are what we need to send messages to the port.
+    // |filter| is just a weak pointer since we get notified when its process has
+    // gone away and remove it.
+    MessagePortMessageFilter* filter;
+    int route_id;
+    // A globally unique id for this message port.
+    int message_port_id;
+    // The globally unique id of the entangled message port.
+    int entangled_message_port_id;
+    // If true, all messages to this message port are queued and not delivered.
+    // This is needed so that when a message port is sent between processes all
+    // pending message get transferred. There are two possibilities for pending
+    // messages: either they are already received by the child process, or they're
+    // in-flight. This flag ensures that the latter type get flushed through the
+    // system.
+    // This flag should only be set to true in response to
+    // MessagePortHostMsg_QueueMessages.
+    bool queue_messages;
+    QueuedMessages queued_messages;
+  };
+
   typedef std::map<int, MessagePort> MessagePorts;
   MessagePorts message_ports_;
 
diff --git a/content/common/gpu/gpu_messages.h b/content/common/gpu/gpu_messages.h
index 936a8a0..084b2d8 100644
--- a/content/common/gpu/gpu_messages.h
+++ b/content/common/gpu/gpu_messages.h
@@ -116,10 +116,12 @@ IPC_STRUCT_BEGIN(GpuStreamTextureMsg_MatrixChanged_Params)
 IPC_STRUCT_END()
 #endif
 
-  IPC_STRUCT_TRAITS_BEGIN(gpu::DxDiagNode)
+#if defined(OS_WIN)
+IPC_STRUCT_TRAITS_BEGIN(gpu::DxDiagNode)
   IPC_STRUCT_TRAITS_MEMBER(values)
   IPC_STRUCT_TRAITS_MEMBER(children)
 IPC_STRUCT_TRAITS_END()
+#endif
 
 IPC_STRUCT_TRAITS_BEGIN(gpu::GpuPerformanceStats)
   IPC_STRUCT_TRAITS_MEMBER(graphics)
diff --git a/content/renderer/media/media_stream_dispatcher.cc b/content/renderer/media/media_stream_dispatcher.cc
index 6890ffc..96f92fb 100644
--- a/content/renderer/media/media_stream_dispatcher.cc
+++ b/content/renderer/media/media_stream_dispatcher.cc
@@ -30,37 +30,6 @@ bool RemoveStreamDeviceFromArray(const StreamDeviceInfo device_info,
 
 }  // namespace
 
-// A request is identified by pair (request_id, handler), or ipc_request.
-// There could be multiple clients making requests and each has its own
-// request_id sequence.
-// The ipc_request is garanteed to be unique when it's created in
-// MediaStreamDispatcher.
-struct MediaStreamDispatcher::Request {
-  Request(const base::WeakPtr<MediaStreamDispatcherEventHandler>& handler,
-          int request_id,
-          int ipc_request)
-      : handler(handler),
-        request_id(request_id),
-        ipc_request(ipc_request) {
-  }
-  bool IsThisRequest(
-      int request_id1,
-      const base::WeakPtr<MediaStreamDispatcherEventHandler>& handler1) {
-    return (request_id1 == request_id && handler1.get() == handler.get());
-  }
-  base::WeakPtr<MediaStreamDispatcherEventHandler> handler;
-  int request_id;
-  int ipc_request;
-};
-
-struct MediaStreamDispatcher::Stream {
-  Stream() {}
-  ~Stream() {}
-  base::WeakPtr<MediaStreamDispatcherEventHandler> handler;
-  StreamDeviceInfoArray audio_array;
-  StreamDeviceInfoArray video_array;
-};
-
 MediaStreamDispatcher::MediaStreamDispatcher(RenderViewImpl* render_view)
     : RenderViewObserver(render_view),
       main_loop_(base::MessageLoopProxy::current()),
diff --git a/content/renderer/media/media_stream_dispatcher.h b/content/renderer/media/media_stream_dispatcher.h
index 89d7c0d..4c08958 100644
--- a/content/renderer/media/media_stream_dispatcher.h
+++ b/content/renderer/media/media_stream_dispatcher.h
@@ -99,11 +99,38 @@ class CONTENT_EXPORT MediaStreamDispatcher
   FRIEND_TEST_ALL_PREFIXES(MediaStreamDispatcherTest, TestFailure);
   FRIEND_TEST_ALL_PREFIXES(MediaStreamDispatcherTest, CancelGenerateStream);
 
-  struct Request;
+  // A request is identified by pair (request_id, handler), or ipc_request.
+  // There could be multiple clients making requests and each has its own
+  // request_id sequence.
+  // The ipc_request is garanteed to be unique when it's created in
+  // MediaStreamDispatcher.
+  struct Request {
+    Request(const base::WeakPtr<MediaStreamDispatcherEventHandler>& handler,
+            int request_id,
+            int ipc_request)
+        : handler(handler),
+          request_id(request_id),
+          ipc_request(ipc_request) {
+    }
+    bool IsThisRequest(
+        int request_id1,
+        const base::WeakPtr<MediaStreamDispatcherEventHandler>& handler1) {
+      return (request_id1 == request_id && handler1.get() == handler.get());
+    }
+    base::WeakPtr<MediaStreamDispatcherEventHandler> handler;
+    int request_id;
+    int ipc_request;
+  };
 
   // Private class for keeping track of opened devices and who have
   // opened it.
-  struct Stream;
+  struct Stream {
+    Stream() {}
+    ~Stream() {}
+    base::WeakPtr<MediaStreamDispatcherEventHandler> handler;
+    StreamDeviceInfoArray audio_array;
+    StreamDeviceInfoArray video_array;
+  };
 
   // RenderViewObserver OVERRIDE.
   virtual bool Send(IPC::Message* message) OVERRIDE;
diff --git a/content/renderer/pepper/message_channel.cc b/content/renderer/pepper/message_channel.cc
index 51132a6..7c5961c 100644
--- a/content/renderer/pepper/message_channel.cc
+++ b/content/renderer/pepper/message_channel.cc
@@ -292,18 +292,6 @@ NPClass message_channel_class = {
 }  // namespace
 
 // MessageChannel --------------------------------------------------------------
-struct MessageChannel::VarConversionResult {
-  VarConversionResult(const ppapi::ScopedPPVar& r, bool s)
-      : result(r),
-        success(s),
-        conversion_completed(true) {}
-  VarConversionResult()
-      : success(false),
-        conversion_completed(false) {}
-  ppapi::ScopedPPVar result;
-  bool success;
-  bool conversion_completed;
-};
 
 MessageChannel::MessageChannelNPObject::MessageChannelNPObject() {
 }
diff --git a/content/renderer/pepper/message_channel.h b/content/renderer/pepper/message_channel.h
index e0020e6..43aa0f9 100644
--- a/content/renderer/pepper/message_channel.h
+++ b/content/renderer/pepper/message_channel.h
@@ -11,15 +11,12 @@
 
 #include "base/memory/weak_ptr.h"
 #include "ppapi/shared_impl/resource.h"
+#include "ppapi/shared_impl/scoped_pp_var.h"
 #include "third_party/WebKit/public/web/WebSerializedScriptValue.h"
 #include "third_party/npapi/bindings/npruntime.h"
 
 struct PP_Var;
 
-namespace ppapi {
-class ScopedPPVar;
-}
-
 namespace content {
 
 class PepperPluginInstanceImpl;
@@ -90,7 +87,18 @@ class MessageChannel {
 
  private:
   // Struct for storing the result of a NPVariant being converted to a PP_Var.
-  struct VarConversionResult;
+  struct VarConversionResult {
+    VarConversionResult(const ppapi::ScopedPPVar& r, bool s)
+        : result(r),
+          success(s),
+          conversion_completed(true) {}
+    VarConversionResult()
+        : success(false),
+          conversion_completed(false) {}
+    ppapi::ScopedPPVar result;
+    bool success;
+    bool conversion_completed;
+  };
 
   // This is called when an NPVariant is finished being converted.
   // |result_iteartor| is an iterator into |converted_var_queue_| where the
diff --git a/gpu/config/dx_diag_node.cc b/gpu/config/dx_diag_node.cc
index e0902ca..c1e84ae 100644
--- a/gpu/config/dx_diag_node.cc
+++ b/gpu/config/dx_diag_node.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/config/dx_diag_node.h"
 
+#if defined(OS_WIN)
+
 namespace gpu {
 
 DxDiagNode::DxDiagNode() {}
@@ -11,3 +13,5 @@ DxDiagNode::DxDiagNode() {}
 DxDiagNode::~DxDiagNode() {}
 
 }  // namespace gpu
+
+#endif // defined(OS_WIN)
diff --git a/gpu/config/dx_diag_node.h b/gpu/config/dx_diag_node.h
index 33d29b3..7f77362 100644
--- a/gpu/config/dx_diag_node.h
+++ b/gpu/config/dx_diag_node.h
@@ -8,6 +8,10 @@
 #ifndef GPU_CONFIG_DX_DIAG_NODE_H_
 #define GPU_CONFIG_DX_DIAG_NODE_H_
 
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
+
 #include <map>
 #include <string>
 
@@ -24,4 +28,6 @@ struct GPU_EXPORT DxDiagNode {
 
 }  // namespace gpu
 
+#endif // defined(OS_WIN)
+
 #endif  // GPU_CONFIG_DX_DIAG_NODE_H_
diff --git a/media/filters/ffmpeg_audio_decoder.cc b/media/filters/ffmpeg_audio_decoder.cc
index 00f7566..bb64c36 100644
--- a/media/filters/ffmpeg_audio_decoder.cc
+++ b/media/filters/ffmpeg_audio_decoder.cc
@@ -23,12 +23,6 @@
 
 namespace media {
 
-// Helper structure for managing multiple decoded audio frames per packet.
-struct QueuedAudioBuffer {
-  AudioDecoder::Status status;
-  scoped_refptr<AudioBuffer> buffer;
-};
-
 // Returns true if the decode result was end of stream.
 static inline bool IsEndOfStream(int result,
                                  int decoded_size,
diff --git a/media/filters/ffmpeg_audio_decoder.h b/media/filters/ffmpeg_audio_decoder.h
index 40103b8..2963847 100644
--- a/media/filters/ffmpeg_audio_decoder.h
+++ b/media/filters/ffmpeg_audio_decoder.h
@@ -26,10 +26,15 @@ namespace media {
 
 class AudioTimestampHelper;
 class DecoderBuffer;
-struct QueuedAudioBuffer;
 class ScopedPtrAVFreeContext;
 class ScopedPtrAVFreeFrame;
 
+// Helper structure for managing multiple decoded audio frames per packet.
+struct QueuedAudioBuffer {
+  AudioDecoder::Status status;
+  scoped_refptr<AudioBuffer> buffer;
+};
+
 class MEDIA_EXPORT FFmpegAudioDecoder : public AudioDecoder {
  public:
   explicit FFmpegAudioDecoder(
diff --git a/net/cert/mock_cert_verifier.cc b/net/cert/mock_cert_verifier.cc
index ea5538e..a30e3d5 100644
--- a/net/cert/mock_cert_verifier.cc
+++ b/net/cert/mock_cert_verifier.cc
@@ -13,25 +13,6 @@
 
 namespace net {
 
-struct MockCertVerifier::Rule {
-  Rule(X509Certificate* cert,
-       const std::string& hostname,
-       const CertVerifyResult& result,
-       int rv)
-      : cert(cert),
-        hostname(hostname),
-        result(result),
-        rv(rv) {
-    DCHECK(cert);
-    DCHECK(result.verified_cert.get());
-  }
-
-  scoped_refptr<X509Certificate> cert;
-  std::string hostname;
-  CertVerifyResult result;
-  int rv;
-};
-
 MockCertVerifier::MockCertVerifier() : default_result_(ERR_CERT_INVALID) {}
 
 MockCertVerifier::~MockCertVerifier() {}
diff --git a/net/cert/mock_cert_verifier.h b/net/cert/mock_cert_verifier.h
index 5af7b7e..704c66b 100644
--- a/net/cert/mock_cert_verifier.h
+++ b/net/cert/mock_cert_verifier.h
@@ -57,7 +57,25 @@ class MockCertVerifier : public CertVerifier {
                                int rv);
 
  private:
-  struct Rule;
+  struct Rule {
+    Rule(X509Certificate* cert,
+         const std::string& hostname,
+         const CertVerifyResult& result,
+         int rv)
+        : cert(cert),
+          hostname(hostname),
+          result(result),
+          rv(rv) {
+      DCHECK(cert);
+      DCHECK(result.verified_cert.get());
+    }
+
+    scoped_refptr<X509Certificate> cert;
+    std::string hostname;
+    CertVerifyResult result;
+    int rv;
+  };
+
   typedef std::list<Rule> RuleList;
 
   int default_result_;
diff --git a/net/dns/mock_host_resolver.cc b/net/dns/mock_host_resolver.cc
index ff5ffbc..25918ba 100644
--- a/net/dns/mock_host_resolver.cc
+++ b/net/dns/mock_host_resolver.cc
@@ -212,37 +212,6 @@ void MockHostResolverBase::ResolveNow(size_t id) {
 
 //-----------------------------------------------------------------------------
 
-struct RuleBasedHostResolverProc::Rule {
-  enum ResolverType {
-    kResolverTypeFail,
-    kResolverTypeSystem,
-    kResolverTypeIPLiteral,
-  };
-
-  ResolverType resolver_type;
-  std::string host_pattern;
-  AddressFamily address_family;
-  HostResolverFlags host_resolver_flags;
-  std::string replacement;
-  std::string canonical_name;
-  int latency_ms;  // In milliseconds.
-
-  Rule(ResolverType resolver_type,
-       const std::string& host_pattern,
-       AddressFamily address_family,
-       HostResolverFlags host_resolver_flags,
-       const std::string& replacement,
-       const std::string& canonical_name,
-       int latency_ms)
-      : resolver_type(resolver_type),
-        host_pattern(host_pattern),
-        address_family(address_family),
-        host_resolver_flags(host_resolver_flags),
-        replacement(replacement),
-        canonical_name(canonical_name),
-        latency_ms(latency_ms) {}
-};
-
 RuleBasedHostResolverProc::RuleBasedHostResolverProc(HostResolverProc* previous)
     : HostResolverProc(previous) {
 }
diff --git a/net/dns/mock_host_resolver.h b/net/dns/mock_host_resolver.h
index 3593fbd..f8a4240 100644
--- a/net/dns/mock_host_resolver.h
+++ b/net/dns/mock_host_resolver.h
@@ -209,7 +209,37 @@ class RuleBasedHostResolverProc : public HostResolverProc {
                       int* os_error) OVERRIDE;
 
  private:
-  struct Rule;
+  struct Rule {
+    enum ResolverType {
+      kResolverTypeFail,
+      kResolverTypeSystem,
+      kResolverTypeIPLiteral,
+    };
+
+    ResolverType resolver_type;
+    std::string host_pattern;
+    AddressFamily address_family;
+    HostResolverFlags host_resolver_flags;
+    std::string replacement;
+    std::string canonical_name;
+    int latency_ms;  // In milliseconds.
+
+    Rule(ResolverType resolver_type,
+         const std::string& host_pattern,
+         AddressFamily address_family,
+         HostResolverFlags host_resolver_flags,
+         const std::string& replacement,
+         const std::string& canonical_name,
+         int latency_ms)
+        : resolver_type(resolver_type),
+          host_pattern(host_pattern),
+          address_family(address_family),
+          host_resolver_flags(host_resolver_flags),
+          replacement(replacement),
+          canonical_name(canonical_name),
+          latency_ms(latency_ms) {}
+  };
+
   typedef std::list<Rule> RuleList;
 
   virtual ~RuleBasedHostResolverProc();