apps/saved_devices_service.cc

// Copyright 2014 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 "apps/saved_devices_service.h"

#include <set>
#include <vector>

#include "apps/saved_devices_service_factory.h"
#include "base/basictypes.h"
#include "base/values.h"
#include "chrome/browser/chrome_notification_types.h"
#include "chrome/browser/profiles/profile.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/notification_service.h"
#include "device/usb/usb_device.h"
#include "device/usb/usb_device_handle.h"
#include "extensions/browser/extension_host.h"
#include "extensions/browser/extension_prefs.h"
#include "extensions/browser/extension_system.h"
#include "extensions/browser/extension_util.h"
#include "extensions/browser/notification_types.h"
#include "extensions/common/permissions/api_permission.h"
#include "extensions/common/permissions/permission_set.h"
#include "extensions/common/permissions/permissions_data.h"

namespace apps {

using device::UsbDevice;
using device::UsbDeviceHandle;
using extensions::APIPermission;
using extensions::Extension;
using extensions::ExtensionHost;
using extensions::ExtensionPrefs;

namespace {

// Preference keys

// The device that the app has permission to access.
const char kDevices[] = "devices";

// The type of device saved.
const char kDeviceType[] = "type";

// Type identifier for USB devices.
const char kDeviceTypeUsb[] = "usb";

// The vendor ID of the device that the app had permission to access.
const char kDeviceVendorId[] = "vendor_id";

// The product ID of the device that the app had permission to access.
const char kDeviceProductId[] = "product_id";

// The serial number of the device that the app has permission to access.
const char kDeviceSerialNumber[] = "serial_number";

// Persists a SavedDeviceEntry in ExtensionPrefs.
void AddSavedDeviceEntry(Profile* profile,
                         const std::string& extension_id,
                         const SavedDeviceEntry& device) {
  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile);
  ExtensionPrefs::ScopedListUpdate update(prefs, extension_id, kDevices);
  base::ListValue* devices = update.Get();
  if (!devices) {
    devices = update.Create();
  }

  base::Value* device_entry = device.ToValue();
  DCHECK(devices->Find(*device_entry) == devices->end());
  devices->Append(device_entry);
}

// Clears all SavedDeviceEntry for the app from ExtensionPrefs.
void ClearSavedDeviceEntries(ExtensionPrefs* prefs,
                             const std::string& extension_id) {
  prefs->UpdateExtensionPref(extension_id, kDevices, NULL);
}

// Returns all SavedDeviceEntries for the app.
std::vector<SavedDeviceEntry> GetSavedDeviceEntries(
    ExtensionPrefs* prefs,
    const std::string& extension_id) {
  std::vector<SavedDeviceEntry> result;
  const base::ListValue* devices = NULL;
  if (!prefs->ReadPrefAsList(extension_id, kDevices, &devices)) {
    return result;
  }

  for (base::ListValue::const_iterator it = devices->begin();
       it != devices->end();
       ++it) {
    const base::DictionaryValue* device_entry = NULL;
    if (!(*it)->GetAsDictionary(&device_entry)) {
      continue;
    }
    int vendor_id;
    if (!device_entry->GetIntegerWithoutPathExpansion(kDeviceVendorId,
                                                      &vendor_id) ||
        vendor_id < 0 || vendor_id > UINT16_MAX) {
      continue;
    }
    int product_id;
    if (!device_entry->GetIntegerWithoutPathExpansion(kDeviceProductId,
                                                      &product_id) ||
        product_id < 0 || product_id > UINT16_MAX) {
      continue;
    }
    base::string16 serial_number;
    if (!device_entry->GetStringWithoutPathExpansion(kDeviceSerialNumber,
                                                     &serial_number)) {
      continue;
    }

    result.push_back(SavedDeviceEntry(vendor_id, product_id, serial_number));
  }
  return result;
}

}  // namespace

SavedDeviceEntry::SavedDeviceEntry(uint16_t vendor_id,
                                   uint16_t product_id,
                                   const base::string16& serial_number)
    : vendor_id(vendor_id),
      product_id(product_id),
      serial_number(serial_number) {
}

base::Value* SavedDeviceEntry::ToValue() const {
  base::DictionaryValue* device_entry_dict = new base::DictionaryValue();
  device_entry_dict->SetStringWithoutPathExpansion(kDeviceType, kDeviceTypeUsb);
  device_entry_dict->SetIntegerWithoutPathExpansion(kDeviceVendorId, vendor_id);
  device_entry_dict->SetIntegerWithoutPathExpansion(kDeviceProductId,
                                                    product_id);
  device_entry_dict->SetStringWithoutPathExpansion(kDeviceSerialNumber,
                                                   serial_number);
  return device_entry_dict;
}

bool SavedDevicesService::SavedDevices::IsRegistered(
    scoped_refptr<UsbDevice> device) const {
  if (ephemeral_devices_.find(device) != ephemeral_devices_.end()) {
    return true;
  }

  bool have_serial_number = false;
  base::string16 serial_number;
  for (std::vector<SavedDeviceEntry>::const_iterator it =
           persistent_devices_.begin();
       it != persistent_devices_.end();
       ++it) {
    if (it->vendor_id != device->vendor_id()) {
      continue;
    }
    if (it->product_id != device->product_id()) {
      continue;
    }
    if (!have_serial_number) {
      if (!device->GetSerialNumber(&serial_number)) {
        break;
      }
      have_serial_number = true;
    }
    if (it->serial_number != serial_number) {
      continue;
    }
    return true;
  }
  return false;
}

void SavedDevicesService::SavedDevices::RegisterDevice(
    scoped_refptr<device::UsbDevice> device,
    base::string16* serial_number) {
  if (serial_number) {
    for (std::vector<SavedDeviceEntry>::const_iterator it =
             persistent_devices_.begin();
         it != persistent_devices_.end();
         ++it) {
      if (it->vendor_id != device->vendor_id()) {
        continue;
      }
      if (it->product_id != device->product_id()) {
        continue;
      }
      if (it->serial_number == *serial_number) {
        return;
      }
    }
    SavedDeviceEntry device_entry = SavedDeviceEntry(
        device->vendor_id(), device->product_id(), *serial_number);
    persistent_devices_.push_back(device_entry);

    content::BrowserThread::PostTask(
        content::BrowserThread::UI,
        FROM_HERE,
        base::Bind(AddSavedDeviceEntry, profile_, extension_id_, device_entry));
  } else {
    // Without a serial number a device cannot be reliably identified when it
    // is reconnected so such devices are only remembered until disconnect.
    // Register an observer here so that this set doesn't grow undefinitely.
    ephemeral_devices_.insert(device);
    device->AddObserver(this);
  }
}

SavedDevicesService::SavedDevices::SavedDevices(Profile* profile,
                                                const std::string& extension_id)
    : profile_(profile), extension_id_(extension_id) {
  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_);
  persistent_devices_ = GetSavedDeviceEntries(prefs, extension_id_);
}

SavedDevicesService::SavedDevices::~SavedDevices() {
  // Only ephemeral devices have an observer registered.
  for (std::set<scoped_refptr<UsbDevice> >::iterator it =
           ephemeral_devices_.begin();
       it != ephemeral_devices_.end();
       ++it) {
    (*it)->RemoveObserver(this);
  }
}

void SavedDevicesService::SavedDevices::OnDisconnect(
    scoped_refptr<UsbDevice> device) {
  // Permission for an ephemeral device lasts only as long as the device is
  // plugged in.
  ephemeral_devices_.erase(device);
  device->RemoveObserver(this);
}

SavedDevicesService::SavedDevicesService(Profile* profile) : profile_(profile) {
  registrar_.Add(this,
                 extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
                 content::NotificationService::AllSources());
  registrar_.Add(this,
                 chrome::NOTIFICATION_APP_TERMINATING,
                 content::NotificationService::AllSources());
}

SavedDevicesService::~SavedDevicesService() {
  for (std::map<std::string, SavedDevices*>::iterator it =
           extension_id_to_saved_devices_.begin();
       it != extension_id_to_saved_devices_.end();
       ++it) {
    delete it->second;
  }
}

// static
SavedDevicesService* SavedDevicesService::Get(Profile* profile) {
  return SavedDevicesServiceFactory::GetForProfile(profile);
}

SavedDevicesService::SavedDevices* SavedDevicesService::GetOrInsert(
    const std::string& extension_id) {
  SavedDevices* saved_devices = Get(extension_id);
  if (saved_devices) {
    return saved_devices;
  }

  saved_devices = new SavedDevices(profile_, extension_id);
  extension_id_to_saved_devices_[extension_id] = saved_devices;
  return saved_devices;
}

std::vector<SavedDeviceEntry> SavedDevicesService::GetAllDevices(
    const std::string& extension_id) const {
  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_);
  return GetSavedDeviceEntries(prefs, extension_id);
}

void SavedDevicesService::Clear(const std::string& extension_id) {
  DCHECK(thread_checker_.CalledOnValidThread());
  ClearSavedDeviceEntries(ExtensionPrefs::Get(profile_), extension_id);
  std::map<std::string, SavedDevices*>::iterator it =
      extension_id_to_saved_devices_.find(extension_id);
  if (it != extension_id_to_saved_devices_.end()) {
    delete it->second;
    extension_id_to_saved_devices_.erase(it);
  }
}

void SavedDevicesService::Observe(int type,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
  switch (type) {
    case extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED: {
      Clear(content::Details<ExtensionHost>(details)->extension_id());
      break;
    }

    case chrome::NOTIFICATION_APP_TERMINATING: {
      // Stop listening to NOTIFICATION_EXTENSION_HOST_DESTROYED in particular
      // as all extension hosts will be destroyed as a result of shutdown.
      registrar_.RemoveAll();
      break;
    }
  }
}

SavedDevicesService::SavedDevices* SavedDevicesService::Get(
    const std::string& extension_id) const {
  DCHECK(thread_checker_.CalledOnValidThread());
  std::map<std::string, SavedDevices*>::const_iterator it =
      extension_id_to_saved_devices_.find(extension_id);
  if (it != extension_id_to_saved_devices_.end()) {
    return it->second;
  }

  return NULL;
}

}  // namespace apps