Add back RenderFrameHost sanity-check to AudioRendererHost.

content/browser/renderer_host/media/audio_renderer_host.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.
 //
 // AudioRendererHost serves audio related requests from AudioRenderer which
 // lives inside the render process and provide access to audio hardware.
 //
 // This class is owned by RenderProcessHostImpl, and instantiated on UI
 // thread, but all other operations and method calls happen on IO thread, so we
 // need to be extra careful about the lifetime of this object. AudioManager is a
@@ skipping 31 matching lines @@
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/atomic_ref_count.h"
 #include "base/gtest_prod_util.h"
+#include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/process/process.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "content/browser/renderer_host/media/audio_output_device_enumerator.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/browser_message_filter.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/resource_context.h"
@@ skipping 60 matching lines @@
   // |have_access| is true only if there is permission to access the device.
   typedef base::Callback<void(bool have_access)> OutputDeviceAccessCB;
 
   // Internal callback type for information requests about an output device.
   // |success| indicates the operation was successful. If true, |device_info|
   // contains data about the device.
   typedef base::Callback<void(bool success,
                               const AudioOutputDeviceInfo& device_info)>
       OutputDeviceInfoCB;
 
+  // The type of a function that is run on the UI thread to check whether the
+  // routing IDs reference a valid RenderFrameHost. The function then runs
+  // |callback| on the IO thread with true/false if valid/invalid.
+  using ValidateRenderFrameIdFunction =

[o1ka, 2016/07/11 10:35:50]

probably #ifdef this as well?

[miu, 2016/07/14 21:36:12]

Based on past experience, we generally don't conditionally compile typedefs in
Chromium when they do not contain platform-specific types. There should be no
additional code generation resulting from this.

+      void (*)(int render_process_id,
+               int render_frame_id,
+               const base::Callback<void(bool)>& callback);
+
   ~AudioRendererHost() override;
 
   // Methods called on IO thread ----------------------------------------------
 
   // Audio related IPC message handlers.
 
   // Request permission to use an output device for use by a stream produced
   // in the RenderFrame referenced by |render_frame_id|.
   // |session_id| is used for unified IO to find out which input device to be
   // opened for the stream. For clients that do not use unified IO,
@@ skipping 37 matching lines @@
   // Proceed with device authorization after translating device ID.
   void OnDeviceIDTranslated(int stream_id,
                             bool device_found,
                             const AudioOutputDeviceInfo& device_info);
 
   // Start the actual creation of an audio stream, after the device
   // authorization process is complete.
   void DoCreateStream(int stream_id,
                       int render_frame_id,
                       const media::AudioParameters& params,
-                      const std::string& device_unique_id);
+                      const std::string& device_unique_id,
+                      bool render_frame_id_is_valid);
 
   // Complete the process of creating an audio stream. This will set up the
   // shared memory or shared socket in low latency mode and send the
   // NotifyStreamCreated message to the peer.
   void DoCompleteCreation(int stream_id);
 
   // Send playing/paused status to the renderer.
   void DoNotifyStreamStateChanged(int stream_id, bool is_playing);
 
   RenderProcessHost::AudioOutputControllerList DoGetOutputControllers() const;
@@ skipping 30 matching lines @@
   // Translate the hashed |device_id| to a unique device ID.
   void TranslateDeviceID(const std::string& device_id,
                          const url::Origin& security_origin,
                          const OutputDeviceInfoCB& callback,
                          const AudioOutputDeviceEnumeration& enumeration);
 
   // Helper method to check if the authorization procedure for stream
   // |stream_id| has started.
   bool IsAuthorizationStarted(int stream_id);
 
+#if DCHECK_IS_ON()
+  // Called from AudioRendererHostTest to override the function that checks for
+  // the existence of the RenderFrameHost at stream creation time.
+  void set_render_frame_id_validate_function_for_testing(
+      ValidateRenderFrameIdFunction function) {
+    validate_render_frame_id_function_ = function;
+  }
+#endif  // DCHECK_IS_ON()
+
   // ID of the RenderProcessHost that owns this instance.
   const int render_process_id_;
 
   media::AudioManager* const audio_manager_;
   AudioMirroringManager* const mirroring_manager_;
   std::unique_ptr<media::AudioLog> audio_log_;
 
   // Used to access to AudioInputDeviceManager.
   MediaStreamManager* media_stream_manager_;
 
   // A map of stream IDs to audio sources.
   AudioEntryMap audio_entries_;
 
   // The number of streams in the playing state. Atomic read safe from any
   // thread, but should only be updated from the IO thread.
   base::AtomicRefCount num_playing_streams_;
 
   // Salt required to translate renderer device IDs to raw device unique IDs
   std::string salt_;
 
   // Map of device authorizations for streams that are not yet created
   // The key is the stream ID, and the value is a pair. The pair's first element
   // is a bool that is true if the authorization process completes successfully.
   // The second element contains the unique ID of the authorized device.
   std::map<int, std::pair<bool, std::string>> authorizations_;
 
+#if DCHECK_IS_ON()
+  // When DCHECKs are turned on, AudioRendererHost will call this function on
+  // the UI thread to validate render frame IDs. A default is set by the
+  // constructor, but this can be overridden by unit tests.
+  ValidateRenderFrameIdFunction validate_render_frame_id_function_;

[o1ka, 2016/07/11 10:35:50]

AudioRendererHost is exported from content.
Is a situation possible that ARH user which is built with DCHECKs off is linked
with ARH built with DCHECKs on, or vise verse? (I've seen problems like that in
other projects, they are not easy to debug.)

[miu, 2016/07/14 21:36:12]

This shouldn't be an issue in the Chromium project. I'm not aware of any support
for linking code built with different build_config.

+#endif  // DCHECK_IS_ON()
+
   // The maximum number of simultaneous streams during the lifetime of this
   // host. Reported as UMA stat at shutdown.
   size_t max_simultaneous_streams_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioRendererHost);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_RENDERER_HOST_H_