Do not pass the origin to MediaDevicesDispatcherHost.

content/renderer/pepper/pepper_device_enumeration_host_helper.cc

 // 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.
 
 #include "content/renderer/pepper/pepper_device_enumeration_host_helper.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 14 matching lines @@
 namespace content {
 
 // Makes sure that StopEnumerateDevices() is called for each EnumerateDevices().
 class PepperDeviceEnumerationHostHelper::ScopedEnumerationRequest
     : public base::SupportsWeakPtr<ScopedEnumerationRequest> {
  public:
   // |owner| must outlive this object.
   ScopedEnumerationRequest(PepperDeviceEnumerationHostHelper* owner,
                            const Delegate::DevicesCallback& callback)
       : callback_(callback), requested_(false), sync_call_(false) {
-    if (!owner->document_url_.is_valid())
+    if (!owner->delegate_) {
+      // If no delegate, return an empty list of devices.
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE,
+          base::Bind(&ScopedEnumerationRequest::EnumerateDevicesCallbackBody,
+                     AsWeakPtr(), std::vector<ppapi::DeviceRefData>()));
       return;
-
-    if (!owner->delegate_)
-      return;
+    }
 
     requested_ = true;
 
     // Note that the callback passed into
     // PepperDeviceEnumerationHostHelper::Delegate::EnumerateDevices() may be
     // called synchronously. In that case, |callback| may destroy this
     // object. So we don't pass in |callback| directly. Instead, we use
     // EnumerateDevicesCallbackBody() to ensure that we always call |callback|
     // asynchronously.
     sync_call_ = true;
     owner->delegate_->EnumerateDevices(
-        owner->device_type_, owner->document_url_,
+        owner->device_type_,
         base::Bind(&ScopedEnumerationRequest::EnumerateDevicesCallbackBody,
                    AsWeakPtr()));
     sync_call_ = false;
   }
 
   bool requested() const { return requested_; }
 
  private:
   void EnumerateDevicesCallbackBody(
       const std::vector<ppapi::DeviceRefData>& devices) {
@@ skipping 21 matching lines @@
     : public base::SupportsWeakPtr<ScopedMonitoringRequest> {
  public:
   // |owner| must outlive this object.
   ScopedMonitoringRequest(PepperDeviceEnumerationHostHelper* owner,
                           const Delegate::DevicesCallback& callback)
       : owner_(owner),
         callback_(callback),
         requested_(false),
         subscription_id_(0) {
     DCHECK(owner_);
-    if (!owner_->document_url_.is_valid())
+    if (!owner->delegate_) {
       return;
-
-    if (!owner->delegate_)
-      return;
+    }
 
     requested_ = true;
 
     // |callback| is never called synchronously by StartMonitoringDevices(),
     // so it is OK to pass it directly, even if |callback| destroys |this|.
     subscription_id_ = owner_->delegate_->StartMonitoringDevices(
-        owner_->device_type_, owner_->document_url_, callback);
+        owner_->device_type_, callback);
   }
 
   ~ScopedMonitoringRequest() {
     if (requested_ && owner_->delegate_) {
       owner_->delegate_->StopMonitoringDevices(owner_->device_type_,
                                                subscription_id_);
     }
   }
 
   bool requested() const { return requested_; }
 
  private:
   PepperDeviceEnumerationHostHelper* const owner_;
   PepperDeviceEnumerationHostHelper::Delegate::DevicesCallback callback_;
   bool requested_;
   int subscription_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedMonitoringRequest);
 };
 
 PepperDeviceEnumerationHostHelper::PepperDeviceEnumerationHostHelper(
     ppapi::host::ResourceHost* resource_host,
     base::WeakPtr<Delegate> delegate,
     PP_DeviceType_Dev device_type,
     const GURL& document_url)
     : resource_host_(resource_host),
       delegate_(delegate),
-      device_type_(device_type),
-      document_url_(document_url) {}
+      device_type_(device_type) {}
 
 PepperDeviceEnumerationHostHelper::~PepperDeviceEnumerationHostHelper() {}
 
 bool PepperDeviceEnumerationHostHelper::HandleResourceMessage(
     const IPC::Message& msg,
     HostMessageContext* context,
     int32_t* result) {
   bool return_value = false;
   *result = InternalHandleResourceMessage(msg, context, &return_value);
   return return_value;
@@ skipping 67 matching lines @@
 void PepperDeviceEnumerationHostHelper::OnNotifyDeviceChange(
     uint32_t callback_id,
     const std::vector<ppapi::DeviceRefData>& devices) {
   resource_host_->host()->SendUnsolicitedReply(
       resource_host_->pp_resource(),
       PpapiPluginMsg_DeviceEnumeration_NotifyDeviceChange(callback_id,
                                                           devices));
 }
 
 }  // namespace content