Fix the breakage on Windows.

content_decryption_module.h

 // 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.
 
 #ifndef CDM_CONTENT_DECRYPTION_MODULE_H_
 #define CDM_CONTENT_DECRYPTION_MODULE_H_
 
 #if defined(_MSC_VER)
 typedef unsigned char uint8_t;
 typedef unsigned int uint32_t;
 typedef int int32_t;
 typedef __int64 int64_t;
 #else
 #include <stdint.h>
 #endif
 
 // Define CDM_API so that functionality implemented by the CDM module
 // can be exported to consumers. Note: the implementation lives in
 // a dynamic library even in a non-component build.
+// Also define CDM_CLASS_API to export class types. We have to add
+// visibility attributes to make sure virtual tables in CDM consumer
+// and CDM implementation are the same. Generally, it was always a
+// good idea, as there're no guarantees about that for the internal
+// symbols, but it has only become a practical issue after
+// introduction of LTO devirtualization. See more details on
+// https://crbug.com/609564#c35
 #if defined(WIN32)
 
+#if defined(__clang__)
+#define CDM_CLASS_API [[clang::lto_visibility_public]]
+#else
+#define CDM_CLASS_API
+#endif
+
 #if defined(CDM_IMPLEMENTATION)
 #define CDM_API __declspec(dllexport)
 #else
 #define CDM_API __declspec(dllimport)
 #endif  // defined(CDM_IMPLEMENTATION)
 
 #else  // defined(WIN32)
 #define CDM_API __attribute__((visibility("default")))
+#define CDM_CLASS_API __attribute__((visibility("default")))
 #endif  // defined(WIN32)
 
 // The version number must be rolled when the exported functions are updated!
 // If the CDM and the adapter use different versions of these functions, the
 // adapter will fail to load or crash!
 #define CDM_MODULE_VERSION 4
 
 // Build the versioned entrypoint name.
 // The extra macros are necessary to expand version to an actual value.
 #define INITIALIZE_CDM_MODULE \
@@ skipping 332 matching lines @@
 
 // FileIO interface provides a way for the CDM to store data in a file in
 // persistent storage. This interface aims only at providing basic read/write
 // capabilities and should not be used as a full fledged file IO API.
 // Each CDM and origin (e.g. HTTPS, "foo.example.com", 443) combination has
 // its own persistent storage. All instances of a given CDM associated with a
 // given origin share the same persistent storage.
 // Note to implementors of this interface:
 // Per-origin storage and the ability for users to clear it are important.
 // See http://www.w3.org/TR/encrypted-media/#privacy-storedinfo.
-class CDM_API FileIO {
+class CDM_CLASS_API FileIO {
  public:
   // Opens the file with |file_name| for read and write.
   // FileIOClient::OnOpenComplete() will be called after the opening
   // operation finishes.
   // - When the file is opened by a CDM instance, it will be classified as "in
   //   use". In this case other CDM instances in the same domain may receive
   //   kInUse status when trying to open it.
   // - |file_name| must not contain forward slash ('/') or backslash ('\'), and
   //   must not start with an underscore ('_').
   virtual void Open(const char* file_name, uint32_t file_name_size) = 0;
@@ skipping 19 matching lines @@
 
  protected:
   FileIO() {}
   virtual ~FileIO() {}
 };
 
 // Responses to FileIO calls. All responses will be called asynchronously.
 // When kError is returned, the FileIO object could be in an error state. All
 // following calls (other than Close()) could return kError. The CDM should
 // still call Close() to destroy the FileIO object.
-class CDM_API FileIOClient {
+class CDM_CLASS_API FileIOClient {
  public:
   enum Status {
     kSuccess = 0,
     kInUse,
     kError
   };
 
   // Response to a FileIO::Open() call with the open |status|.
   virtual void OnOpenComplete(Status status) = 0;
 
@@ skipping 20 matching lines @@
   FileIOClient() {}
   virtual ~FileIOClient() {}
 };
 
 // ContentDecryptionModule interface that all CDMs need to implement.
 // The interface is versioned for backward compatibility.
 // Note: ContentDecryptionModule implementations must use the allocator
 // provided in CreateCdmInstance() to allocate any Buffer that needs to
 // be passed back to the caller. Implementations must call Buffer::Destroy()
 // when a Buffer is created that will never be returned to the caller.
-class CDM_API ContentDecryptionModule_7 {
+class CDM_CLASS_API ContentDecryptionModule_7 {
  public:
   static const int kVersion = 7;
   typedef Host_7 Host;
 
   // SetServerCertificate(), CreateSessionAndGenerateRequest(), LoadSession(),
   // UpdateSession(), CloseSession(), and RemoveSession() all accept a
   // |promise_id|, which must be passed to the completion Host method
   // (e.g. Host::OnResolveNewSessionPromise()).
 
   // Provides a server certificate to be used to encrypt messages to the
@@ skipping 158 matching lines @@
   ContentDecryptionModule_7() {}
   virtual ~ContentDecryptionModule_7() {}
 };
 
 // ContentDecryptionModule interface that all CDMs need to implement.
 // The interface is versioned for backward compatibility.
 // Note: ContentDecryptionModule implementations must use the allocator
 // provided in CreateCdmInstance() to allocate any Buffer that needs to
 // be passed back to the caller. Implementations must call Buffer::Destroy()
 // when a Buffer is created that will never be returned to the caller.
-class CDM_API ContentDecryptionModule_8 {
+class CDM_CLASS_API ContentDecryptionModule_8 {
  public:
   static const int kVersion = 8;
   typedef Host_8 Host;
 
   // Initializes the CDM instance, providing information about permitted
   // functionalities.
   // If |allow_distinctive_identifier| is false, messages from the CDM,
   // such as message events, must not contain a Distinctive Identifier,
   // even in an encrypted form.
   // If |allow_persistent_state| is false, the CDM must not attempt to
@@ skipping 164 matching lines @@
   virtual void Destroy() = 0;
 
  protected:
   ContentDecryptionModule_8() {}
   virtual ~ContentDecryptionModule_8() {}
 };
 
 typedef ContentDecryptionModule_8 ContentDecryptionModule;
 
 // Represents a buffer created by Allocator implementations.
-class CDM_API Buffer {
+class CDM_CLASS_API Buffer {
  public:
   // Destroys the buffer in the same context as it was created.
   virtual void Destroy() = 0;
 
   virtual uint32_t Capacity() const = 0;
   virtual uint8_t* Data() = 0;
   virtual void SetSize(uint32_t size) = 0;
   virtual uint32_t Size() const = 0;
 
  protected:
   Buffer() {}
   virtual ~Buffer() {}
 
  private:
   Buffer(const Buffer&);
   void operator=(const Buffer&);
 };
 
-class CDM_API Host_7 {
+class CDM_CLASS_API Host_7 {
  public:
   static const int kVersion = 7;
 
   // Returns a Buffer* containing non-zero members upon success, or NULL on
   // failure. The caller owns the Buffer* after this call. The buffer is not
   // guaranteed to be zero initialized. The capacity of the allocated Buffer
   // is guaranteed to be not less than |capacity|.
   virtual Buffer* Allocate(uint32_t capacity) = 0;
 
   // Requests the host to call ContentDecryptionModule::TimerFired() |delay_ms|
@@ skipping 116 matching lines @@
   // if a FileIO object cannot be obtained. Once a valid FileIO object is
   // returned, |client| must be valid until FileIO::Close() is called. The
   // CDM can call this method multiple times to operate on different files.
   virtual FileIO* CreateFileIO(FileIOClient* client) = 0;
 
  protected:
   Host_7() {}
   virtual ~Host_7() {}
 };
 
-class CDM_API Host_8 {
+class CDM_CLASS_API Host_8 {
  public:
   static const int kVersion = 8;
 
   // Returns a Buffer* containing non-zero members upon success, or NULL on
   // failure. The caller owns the Buffer* after this call. The buffer is not
   // guaranteed to be zero initialized. The capacity of the allocated Buffer
   // is guaranteed to be not less than |capacity|.
   virtual Buffer* Allocate(uint32_t capacity) = 0;
 
   // Requests the host to call ContentDecryptionModule::TimerFired() |delay_ms|
@@ skipping 117 matching lines @@
   // returned, |client| must be valid until FileIO::Close() is called. The
   // CDM can call this method multiple times to operate on different files.
   virtual FileIO* CreateFileIO(FileIOClient* client) = 0;
 
  protected:
   Host_8() {}
   virtual ~Host_8() {}
 };
 
 // Represents a decrypted block that has not been decoded.
-class CDM_API DecryptedBlock {
+class CDM_CLASS_API DecryptedBlock {
  public:
   virtual void SetDecryptedBuffer(Buffer* buffer) = 0;
   virtual Buffer* DecryptedBuffer() = 0;
 
   // TODO(tomfinegan): Figure out if timestamp is really needed. If it is not,
   // we can just pass Buffer pointers around.
   virtual void SetTimestamp(int64_t timestamp) = 0;
   virtual int64_t Timestamp() const = 0;
 
  protected:
   DecryptedBlock() {}
   virtual ~DecryptedBlock() {}
 };
 
-class CDM_API VideoFrame {
+class CDM_CLASS_API VideoFrame {
  public:
   enum VideoPlane {
     kYPlane = 0,
     kUPlane = 1,
     kVPlane = 2,
     kMaxPlanes = 3,
   };
 
   virtual void SetFormat(VideoFormat format) = 0;
   virtual VideoFormat Format() const = 0;
@@ skipping 22 matching lines @@
 // multiple audio output buffers, which are serialized into this format:
 //
 // |<------------------- serialized audio buffer ------------------->|
 // | int64_t timestamp | int64_t length | length bytes of audio data |
 //
 // For example, with three audio output buffers, the AudioFrames will look
 // like this:
 //
 // |<----------------- AudioFrames ------------------>|
 // | audio buffer 0 | audio buffer 1 | audio buffer 2 |
-class CDM_API AudioFrames {
+class CDM_CLASS_API AudioFrames {
  public:
   virtual void SetFrameBuffer(Buffer* buffer) = 0;
   virtual Buffer* FrameBuffer() = 0;
 
   // The CDM must call this method, providing a valid format, when providing
   // frame buffers. Planar data should be stored end to end; e.g.,
   // |ch1 sample1||ch1 sample2|....|ch1 sample_last||ch2 sample1|...
   virtual void SetFormat(AudioFormat format) = 0;
   virtual AudioFormat Format() const = 0;
 
  protected:
   AudioFrames() {}
   virtual ~AudioFrames() {}
 };
 
 }  // namespace cdm
 
 #endif  // CDM_CONTENT_DECRYPTION_MODULE_H_