Supresses app permissions changed dialogs in kiosk mode.

chrome/browser/usb/usb_service.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 "chrome/browser/usb/usb_service.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "chrome/browser/usb/usb_device.h"
 #include "third_party/libusb/src/libusb/libusb.h"
 
 #if defined(OS_CHROMEOS)
+#include "base/chromeos/chromeos_version.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/permission_broker_client.h"
 #endif  // defined(OS_CHROMEOS)
 
 using std::vector;
 
 // The UsbEventHandler works around a design flaw in the libusb interface. There
 // is currently no way to signal to libusb that any caller into one of the event
 // handler calls should return without handling any events.
 class UsbEventHandler : public base::PlatformThread::Delegate {
@@ skipping 40 matching lines @@
   event_handler_->Stop();
   event_handler_ = NULL;
 }
 
 void UsbService::FindDevices(const uint16 vendor_id,
                              const uint16 product_id,
                              vector<scoped_refptr<UsbDevice> >* devices,
                              const base::Callback<void()>& callback) {
   DCHECK(event_handler_) << "FindDevices called after event handler stopped.";
 #if defined(OS_CHROMEOS)
-  chromeos::PermissionBrokerClient* client =
-      chromeos::DBusThreadManager::Get()->GetPermissionBrokerClient();
-  DCHECK(client) << "Could not get permission broker client.";
-  if (!client) {
-    callback.Run();
-    return;
+  // ChromeOS builds on non-ChromeOS machines (dev) should not attempt to
+  // use permission broker.
+  if (base::chromeos::IsRunningOnChromeOS()) {
+    chromeos::PermissionBrokerClient* client =
+        chromeos::DBusThreadManager::Get()->GetPermissionBrokerClient();
+    DCHECK(client) << "Could not get permission broker client.";
+    if (!client) {
+      callback.Run();
+      return;
+    }
+
+    client->RequestUsbAccess(vendor_id,
+                             product_id,
+                             base::Bind(&UsbService::FindDevicesImpl,
+                                        base::Unretained(this),
+                                        vendor_id,
+                                        product_id,
+                                        devices,
+                                        callback));
+  } else {
+    FindDevicesImpl(vendor_id, product_id, devices, callback, true);
   }
-
-  client->RequestUsbAccess(vendor_id,
-                           product_id,
-                           base::Bind(&UsbService::FindDevicesImpl,
-                                      base::Unretained(this),
-                                      vendor_id,
-                                      product_id,
-                                      devices,
-                                      callback));
 #else
   FindDevicesImpl(vendor_id, product_id, devices, callback, true);
 #endif  // defined(OS_CHROMEOS)
 }
 
 void UsbService::FindDevicesImpl(const uint16 vendor_id,
                                  const uint16 product_id,
                                  vector<scoped_refptr<UsbDevice> >* devices,
                                  const base::Callback<void()>& callback,
                                  bool success) {
@@ skipping 85 matching lines @@
     if (libusb_open(device, &handle)) {
       LOG(WARNING) << "Could not open device.";
       return NULL;
     }
 
     UsbDevice* wrapper = new UsbDevice(this, handle);
     devices_[device] = wrapper;
   }
   return devices_[device];
 }