Includes, comments and bugfixes

- Fix includes
- Use common regex (Song::kCoverRemoveDisc) for removing Disc/CD from album
- Remove Disc/CD from album when creating hash
- Make imobiledevice support compile
- Fix setting device on windows

ext/libstrawberry-common/core/messagehandler.h

@@ -18,21 +18,21 @@
 #ifndef MESSAGEHANDLER_H
 #define MESSAGEHANDLER_H
 
-#include <QBuffer>
-#include <QMap>
-#include <QMutex>
-#include <QMutexLocker>
+#include <string>
+
+#include <QtGlobal>
 #include <QObject>
-#include <QSemaphore>
 #include <QThread>
+#include <QIODevice>
+#include <QBuffer>
+#include <QByteArray>
+#include <QMap>
+#include <QString>
+#include <QLocalSocket>
+#include <QAbstractSocket>
 
-#include "core/logging.h"
 #include "core/messagereply.h"
 
-class QAbstractSocket;
-class QIODevice;
-class QLocalSocket;
-
 #define QStringFromStdString(x) QString::fromUtf8(x.data(), x.size())
 #define DataCommaSizeFromQString(x) x.toUtf8().constData(), x.toUtf8().length()
 
@@ -45,27 +45,27 @@ class _MessageHandlerBase : public QObject {
 public:
   // device can be NULL, in which case you must call SetDevice before writing
   // any messages.
-  _MessageHandlerBase(QIODevice* device, QObject* parent);
+  _MessageHandlerBase(QIODevice *device, QObject *parent);
 
-  void SetDevice(QIODevice* device);
+  void SetDevice(QIODevice *device);
 
   // After this is true, messages cannot be sent to the handler any more.
   bool is_device_closed() const { return is_device_closed_; }
 
 protected slots:
-  void WriteMessage(const QByteArray& data);
+  void WriteMessage(const QByteArray &data);
   void DeviceReadyRead();
   virtual void DeviceClosed();
 
 protected:
-  virtual bool RawMessageArrived(const QByteArray& data) = 0;
+  virtual bool RawMessageArrived(const QByteArray &data) = 0;
   virtual void AbortAll() = 0;
 
 protected:
   typedef bool (QAbstractSocket::*FlushAbstractSocket)();
   typedef bool (QLocalSocket::*FlushLocalSocket)();
 
-  QIODevice* device_;
+  QIODevice *device_;
   FlushAbstractSocket flush_abstract_socket_;
   FlushLocalSocket flush_local_socket_;
 
@@ -82,7 +82,7 @@ protected:
 template <typename MT>
 class AbstractMessageHandler : public _MessageHandlerBase {
 public:
-  AbstractMessageHandler(QIODevice* device, QObject* parent);
+  AbstractMessageHandler(QIODevice *device, QObject *parent);
   ~AbstractMessageHandler() { AbortAll(); }
 
   typedef MT MessageType;
@@ -90,27 +90,27 @@ public:
 
   // Serialises the message and writes it to the socket.  This version MUST be
   // called from the thread in which the AbstractMessageHandler was created.
-  void SendMessage(const MessageType& message);
+  void SendMessage(const MessageType &message);
 
   // Serialises the message and writes it to the socket.  This version may be
   // called from any thread.
-  void SendMessageAsync(const MessageType& message);
+  void SendMessageAsync(const MessageType &message);
 
   // Sends the request message inside and takes ownership of the MessageReply.
   // The MessageReply's Finished() signal will be emitted when a reply arrives
   // with the same ID.  Must be called from my thread.
-  void SendRequest(ReplyType* reply);
+  void SendRequest(ReplyType *reply);
 
   // Sets the "id" field of reply to the same as the request, and sends the
   // reply on the socket.  Used on the worker side.
-  void SendReply(const MessageType& request, MessageType* reply);
+  void SendReply(const MessageType &request, MessageType *reply);
 
 protected:
   // Called when a message is received from the socket.
-  virtual void MessageArrived(const MessageType& message) {}
+  virtual void MessageArrived(const MessageType &message) {}
 
   // _MessageHandlerBase
-  bool RawMessageArrived(const QByteArray& data);
+  bool RawMessageArrived(const QByteArray &data);
   void AbortAll();
 
 private:
@@ -118,12 +118,11 @@ private:
 };
 
 template <typename MT>
-AbstractMessageHandler<MT>::AbstractMessageHandler(QIODevice* device,
-                                                   QObject* parent)
+AbstractMessageHandler<MT>::AbstractMessageHandler(QIODevice *device, QObject *parent)
     : _MessageHandlerBase(device, parent) {}
 
 template <typename MT>
-void AbstractMessageHandler<MT>::SendMessage(const MessageType& message) {
+void AbstractMessageHandler<MT>::SendMessage(const MessageType &message) {
   Q_ASSERT(QThread::currentThread() == thread());
 
   std::string data = message.SerializeAsString();
@@ -131,33 +130,32 @@ void AbstractMessageHandler<MT>::SendMessage(const MessageType& message) {
 }
 
 template <typename MT>
-void AbstractMessageHandler<MT>::SendMessageAsync(const MessageType& message) {
+void AbstractMessageHandler<MT>::SendMessageAsync(const MessageType &message) {
   std::string data = message.SerializeAsString();
   metaObject()->invokeMethod(this, "WriteMessage", Qt::QueuedConnection,
       Q_ARG(QByteArray, QByteArray(data.data(), data.size())));
 }
 
 template<typename MT>
-void AbstractMessageHandler<MT>::SendRequest(ReplyType* reply) {
+void AbstractMessageHandler<MT>::SendRequest(ReplyType *reply) {
   pending_replies_[reply->id()] = reply;
   SendMessage(reply->request_message());
 }
 
 template<typename MT>
-void AbstractMessageHandler<MT>::SendReply(const MessageType& request,
-                                           MessageType* reply) {
+void AbstractMessageHandler<MT>::SendReply(const MessageType &request, MessageType *reply) {
   reply->set_id(request.id());
   SendMessage(*reply);
 }
 
 template<typename MT>
-bool AbstractMessageHandler<MT>::RawMessageArrived(const QByteArray& data) {
+bool AbstractMessageHandler<MT>::RawMessageArrived(const QByteArray &data) {
   MessageType message;
   if (!message.ParseFromArray(data.constData(), data.size())) {
     return false;
   }
 
-  ReplyType* reply = pending_replies_.take(message.id());
+  ReplyType *reply = pending_replies_.take(message.id());
 
   if (reply) {
     // This is a reply to a message that we created earlier.
@@ -171,7 +169,7 @@ bool AbstractMessageHandler<MT>::RawMessageArrived(const QByteArray& data) {
 
 template<typename MT>
 void AbstractMessageHandler<MT>::AbortAll() {
-  for (ReplyType* reply : pending_replies_) {
+  for (ReplyType *reply : pending_replies_) {
     reply->Abort();
   }
   pending_replies_.clear();