1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101
  102
  103
  104
  105
  106
  107
  108
  109
  110


media / midi / midi_service.h [blame]

// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef MEDIA_MIDI_MIDI_SERVICE_H_
#define MEDIA_MIDI_MIDI_SERVICE_H_

#include <stdint.h>

#include <memory>
#include <vector>

#include "base/memory/scoped_refptr.h"
#include "base/synchronization/lock.h"
#include "base/task/single_thread_task_runner.h"
#include "base/threading/thread.h"
#include "base/time/time.h"
#include "media/midi/midi_export.h"
#include "media/midi/midi_manager.h"

namespace midi {

class TaskService;

// Manages MidiManager backends.  This class expects to be constructed and
// destructed on the browser main thread, but methods can be called on both
// the main thread and the I/O thread.
class MIDI_EXPORT MidiService final {
 public:
  class MIDI_EXPORT ManagerFactory {
   public:
    ManagerFactory() = default;

    ManagerFactory(const ManagerFactory&) = delete;
    ManagerFactory& operator=(const ManagerFactory&) = delete;

    virtual ~ManagerFactory() = default;
    virtual std::unique_ptr<MidiManager> Create(MidiService* service);
  };

  // Converts Web MIDI timestamp to base::TimeDelta delay for PostDelayedTask.
  static base::TimeDelta TimestampToTimeDeltaDelay(base::TimeTicks timestamp);

  MidiService();
  // Customized ManagerFactory can be specified in the constructor for testing.
  explicit MidiService(std::unique_ptr<ManagerFactory> factory);

  MidiService(const MidiService&) = delete;
  MidiService& operator=(const MidiService&) = delete;

  ~MidiService();

  // Called on the browser main thread to notify the I/O thread will stop and
  // the instance will be destructed on the main thread soon.
  void Shutdown();

  // A client calls StartSession() to receive and send MIDI data.
  void StartSession(MidiManagerClient* client);

  // A client calls EndSession() to stop receiving MIDI data.
  // Returns false if |client| did not start a session.
  bool EndSession(MidiManagerClient* client);

  // A client calls DispatchSendMidiData() to send MIDI data.
  void DispatchSendMidiData(MidiManagerClient* client,
                            uint32_t port_index,
                            const std::vector<uint8_t>& data,
                            base::TimeTicks timestamp);

  // Returns a SingleThreadTaskRunner reference to serve MidiManager. Each
  // TaskRunner will be constructed on demand.
  // MidiManager that supports the dynamic instantiation feature will use this
  // method to post tasks that should not run on I/O. Since TaskRunners outlive
  // MidiManager, each task should ensure that MidiManager that posted the task
  // is still alive while accessing |this|. TaskRunners will be reused when
  // another MidiManager is instantiated.
  // TODO(toyoshim): Remove this interface.
  scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner(size_t runner_id);

  // Obtains a TaskService that lives with MidiService.
  TaskService* task_service() { return task_service_.get(); }

 private:
  // ManagerFactory passed in the constructor.
  std::unique_ptr<ManagerFactory> manager_factory_;

  // Holds MidiManager instance. The MidiManager is constructed and destructed
  // on the I/O thread, and all MidiManager methods should be called on the I/O
  // thread.
  std::unique_ptr<MidiManager> manager_;

  // Holds TaskService instance.
  std::unique_ptr<TaskService> task_service_;

  // TaskRunner to destruct |manager_| on the right thread.
  scoped_refptr<base::SingleThreadTaskRunner> manager_destructor_runner_;

  // Protects all members above.
  base::Lock lock_;

  // Threads to host SingleThreadTaskRunners.
  std::vector<std::unique_ptr<base::Thread>> threads_;

  // Protects |threads_|.
  base::Lock threads_lock_;
};

}  // namespace midi

#endif  // MEDIA_MIDI_MIDI_SERVICE_H_