diff -ur ext/clementine-spotifyblob/spotifyclient.cpp ext/clementine-spotifyblob/spotifyclient.cpp
--- a/ext/clementine-spotifyblob/spotifyclient.cpp	2020-09-23 22:34:08.000000000 -0400
+++ b/ext/clementine-spotifyblob/spotifyclient.cpp	2021-02-19 12:03:48.233473023 -0500
@@ -40,7 +40,7 @@
 const int SpotifyClient::kWaveHeaderSize = 44;
 
 SpotifyClient::SpotifyClient(QObject* parent)
-    : AbstractMessageHandler<pb::spotify::Message>(nullptr, parent),
+    : AbstractMessageHandler<cpb::spotify::Message>(nullptr, parent),
       api_key_(QByteArray::fromBase64(kSpotifyApiKey)),
       protocol_socket_(new QTcpSocket(this)),
       session_(nullptr),
@@ -119,8 +119,8 @@
   SpotifyClient* me =
       reinterpret_cast<SpotifyClient*>(sp_session_userdata(session));
   const bool success = error == SP_ERROR_OK;
-  pb::spotify::LoginResponse_Error error_code =
-      pb::spotify::LoginResponse_Error_Other;
+  cpb::spotify::LoginResponse_Error error_code =
+      cpb::spotify::LoginResponse_Error_Other;
 
   if (!success) {
     qLog(Warning) << "Failed to login" << sp_error_message(error);
@@ -128,16 +128,16 @@
 
   switch (error) {
     case SP_ERROR_BAD_USERNAME_OR_PASSWORD:
-      error_code = pb::spotify::LoginResponse_Error_BadUsernameOrPassword;
+      error_code = cpb::spotify::LoginResponse_Error_BadUsernameOrPassword;
       break;
     case SP_ERROR_USER_BANNED:
-      error_code = pb::spotify::LoginResponse_Error_UserBanned;
+      error_code = cpb::spotify::LoginResponse_Error_UserBanned;
       break;
     case SP_ERROR_USER_NEEDS_PREMIUM:
-      error_code = pb::spotify::LoginResponse_Error_UserNeedsPremium;
+      error_code = cpb::spotify::LoginResponse_Error_UserNeedsPremium;
       break;
     default:
-      error_code = pb::spotify::LoginResponse_Error_Other;
+      error_code = cpb::spotify::LoginResponse_Error_Other;
       break;
   }
 
@@ -166,7 +166,7 @@
   qLog(Debug) << "libspotify:" << QString::fromUtf8(data).trimmed();
 }
 
-void SpotifyClient::Search(const pb::spotify::SearchRequest& req) {
+void SpotifyClient::Search(const cpb::spotify::SearchRequest& req) {
   sp_search* search =
       sp_search_create(session_, req.query().c_str(), 0, req.limit(), 0,
                        req.limit_album(), 0, 0,  // artists
@@ -221,11 +221,11 @@
 
 void SpotifyClient::SendSearchResponse(sp_search* result) {
   // Take the request out of the queue
-  pb::spotify::SearchRequest req = pending_searches_.take(result);
+  cpb::spotify::SearchRequest req = pending_searches_.take(result);
 
   // Prepare the response
-  pb::spotify::Message message;
-  pb::spotify::SearchResponse* response = message.mutable_search_response();
+  cpb::spotify::Message message;
+  cpb::spotify::SearchResponse* response = message.mutable_search_response();
 
   *response->mutable_request() = req;
 
@@ -250,7 +250,7 @@
   QList<sp_albumbrowse*> browses = pending_search_album_browses_.take(result);
   for (sp_albumbrowse* browse : browses) {
     sp_album* album = sp_albumbrowse_album(browse);
-    pb::spotify::Album* msg = response->add_album();
+    cpb::spotify::Album* msg = response->add_album();
 
     ConvertAlbum(album, msg->mutable_metadata());
     ConvertAlbumBrowse(browse, msg->mutable_metadata());
@@ -272,7 +272,7 @@
   sp_search_release(result);
 }
 
-void SpotifyClient::MessageArrived(const pb::spotify::Message& message) {
+void SpotifyClient::MessageArrived(const cpb::spotify::Message& message) {
   if (message.has_login_request()) {
     Login(message.login_request());
   } else if (message.has_load_playlist_request()) {
@@ -303,16 +303,16 @@
 }
 
 void SpotifyClient::SetPlaybackSettings(
-    const pb::spotify::PlaybackSettings& req) {
+    const cpb::spotify::PlaybackSettings& req) {
   sp_bitrate bitrate = SP_BITRATE_320k;
   switch (req.bitrate()) {
-    case pb::spotify::Bitrate96k:
+    case cpb::spotify::Bitrate96k:
       bitrate = SP_BITRATE_96k;
       break;
-    case pb::spotify::Bitrate160k:
+    case cpb::spotify::Bitrate160k:
       bitrate = SP_BITRATE_160k;
       break;
-    case pb::spotify::Bitrate320k:
+    case cpb::spotify::Bitrate320k:
       bitrate = SP_BITRATE_320k;
       break;
   }
@@ -325,12 +325,12 @@
   sp_session_set_volume_normalization(session_, req.volume_normalisation());
 }
 
-void SpotifyClient::Login(const pb::spotify::LoginRequest& req) {
+void SpotifyClient::Login(const cpb::spotify::LoginRequest& req) {
   sp_error error = sp_session_create(&spotify_config_, &session_);
   if (error != SP_ERROR_OK) {
     qLog(Warning) << "Failed to create session" << sp_error_message(error);
     SendLoginCompleted(false, sp_error_message(error),
-                       pb::spotify::LoginResponse_Error_Other);
+                       cpb::spotify::LoginResponse_Error_Other);
     return;
   }
 
@@ -341,7 +341,7 @@
     if (error != SP_ERROR_OK) {
       qLog(Warning) << "Tried to relogin but no stored credentials";
       SendLoginCompleted(false, sp_error_message(error),
-                         pb::spotify::LoginResponse_Error_ReloginFailed);
+                         cpb::spotify::LoginResponse_Error_ReloginFailed);
     }
   } else {
     sp_session_login(session_, req.username().c_str(), req.password().c_str(),
@@ -352,10 +352,10 @@
 
 void SpotifyClient::SendLoginCompleted(
     bool success, const QString& error,
-    pb::spotify::LoginResponse_Error error_code) {
-  pb::spotify::Message message;
+    cpb::spotify::LoginResponse_Error error_code) {
+  cpb::spotify::Message message;
 
-  pb::spotify::LoginResponse* response = message.mutable_login_response();
+  cpb::spotify::LoginResponse* response = message.mutable_login_response();
   response->set_success(success);
   response->set_error(DataCommaSizeFromQString(error));
 
@@ -412,8 +412,8 @@
 }
 
 void SpotifyClient::SendPlaylistList() {
-  pb::spotify::Message message;
-  pb::spotify::Playlists* response = message.mutable_playlists_updated();
+  cpb::spotify::Message message;
+  cpb::spotify::Playlists* response = message.mutable_playlists_updated();
 
   sp_playlistcontainer* container = sp_session_playlistcontainer(session_);
   if (!container) {
@@ -441,7 +441,7 @@
       continue;
     }
 
-    pb::spotify::Playlists::Playlist* msg = response->add_playlist();
+    cpb::spotify::Playlists::Playlist* msg = response->add_playlist();
     msg->set_index(i);
     msg->set_name(sp_playlist_name(playlist));
     sp_user* playlist_owner = sp_playlist_owner(playlist);
@@ -470,19 +470,19 @@
   SendMessage(message);
 }
 
-sp_playlist* SpotifyClient::GetPlaylist(pb::spotify::PlaylistType type,
+sp_playlist* SpotifyClient::GetPlaylist(cpb::spotify::PlaylistType type,
                                         int user_index) {
   sp_playlist* playlist = nullptr;
   switch (type) {
-    case pb::spotify::Inbox:
+    case cpb::spotify::Inbox:
       playlist = sp_session_inbox_create(session_);
       break;
 
-    case pb::spotify::Starred:
+    case cpb::spotify::Starred:
       playlist = sp_session_starred_create(session_);
       break;
 
-    case pb::spotify::UserPlaylist: {
+    case cpb::spotify::UserPlaylist: {
       sp_playlistcontainer* pc = sp_session_playlistcontainer(session_);
 
       if (pc && user_index <= sp_playlistcontainer_num_playlists(pc)) {
@@ -499,7 +499,7 @@
   return playlist;
 }
 
-void SpotifyClient::LoadPlaylist(const pb::spotify::LoadPlaylistRequest& req) {
+void SpotifyClient::LoadPlaylist(const cpb::spotify::LoadPlaylistRequest& req) {
   PendingLoadPlaylist pending_load;
   pending_load.request_ = req;
   pending_load.playlist_ = GetPlaylist(req.type(), req.user_playlist_index());
@@ -509,8 +509,8 @@
   if (!pending_load.playlist_) {
     qLog(Warning) << "Invalid playlist requested or not logged in";
 
-    pb::spotify::Message message;
-    pb::spotify::LoadPlaylistResponse* response =
+    cpb::spotify::Message message;
+    cpb::spotify::LoadPlaylistResponse* response =
         message.mutable_load_playlist_response();
     *response->mutable_request() = req;
     SendMessage(message);
@@ -524,7 +524,7 @@
   PlaylistStateChangedForLoadPlaylist(pending_load.playlist_, this);
 }
 
-void SpotifyClient::SyncPlaylist(const pb::spotify::SyncPlaylistRequest& req) {
+void SpotifyClient::SyncPlaylist(const cpb::spotify::SyncPlaylistRequest& req) {
   sp_playlist* playlist =
       GetPlaylist(req.request().type(), req.request().user_playlist_index());
 
@@ -577,13 +577,13 @@
   }
 
   // Everything is loaded so send the response protobuf and unref everything.
-  pb::spotify::Message message;
-  pb::spotify::LoadPlaylistResponse* response =
+  cpb::spotify::Message message;
+  cpb::spotify::LoadPlaylistResponse* response =
       message.mutable_load_playlist_response();
 
   // For some reason, we receive the starred tracks in reverse order but not
   // other playlists.
-  if (pending_load->request_.type() == pb::spotify::Starred) {
+  if (pending_load->request_.type() == cpb::spotify::Starred) {
     std::reverse(pending_load->tracks_.begin(), pending_load->tracks_.end());
   }
 
@@ -610,7 +610,7 @@
 }
 
 void SpotifyClient::AddTracksToPlaylist(
-    const pb::spotify::AddTracksToPlaylistRequest& req) {
+    const cpb::spotify::AddTracksToPlaylistRequest& req) {
   // Get the playlist we want to update
   sp_playlist* playlist =
       GetPlaylist(req.playlist_type(), req.playlist_index());
@@ -649,7 +649,7 @@
 }
 
 void SpotifyClient::RemoveTracksFromPlaylist(
-    const pb::spotify::RemoveTracksFromPlaylistRequest& req) {
+    const cpb::spotify::RemoveTracksFromPlaylistRequest& req) {
   // Get the playlist we want to update
   sp_playlist* playlist =
       GetPlaylist(req.playlist_type(), req.playlist_index());
@@ -667,7 +667,7 @@
 
   // WTF: sp_playlist_remove_tracks indexes start from the end for starred
   // playlist, not from the beginning like other playlists: reverse them
-  if (req.playlist_type() == pb::spotify::Starred) {
+  if (req.playlist_type() == cpb::spotify::Starred) {
     int num_tracks = sp_playlist_num_tracks(playlist);
     for (int i = 0; i < req.track_index_size(); i++) {
       tracks_indices_array[i] = num_tracks - tracks_indices_array[i] - 1;
@@ -680,7 +680,7 @@
   }
 }
 
-void SpotifyClient::ConvertTrack(sp_track* track, pb::spotify::Track* pb) {
+void SpotifyClient::ConvertTrack(sp_track* track, cpb::spotify::Track* pb) {
   sp_album* album = sp_track_album(track);
 
   pb->set_starred(sp_track_is_starred(session_, track));
@@ -713,7 +713,7 @@
   pb->set_uri(uri);
 }
 
-void SpotifyClient::ConvertAlbum(sp_album* album, pb::spotify::Track* pb) {
+void SpotifyClient::ConvertAlbum(sp_album* album, cpb::spotify::Track* pb) {
   pb->set_album(sp_album_name(album));
   pb->set_year(sp_album_year(album));
   pb->add_artist(sp_artist_name(sp_album_artist(album)));
@@ -744,7 +744,7 @@
 }
 
 void SpotifyClient::ConvertAlbumBrowse(sp_albumbrowse* browse,
-                                       pb::spotify::Track* pb) {
+                                       cpb::spotify::Track* pb) {
   pb->set_track(sp_albumbrowse_num_tracks(browse));
 }
 
@@ -853,7 +853,7 @@
 
     int download_progress = me->GetDownloadProgress(playlist);
     if (download_progress != -1) {
-      me->SendDownloadProgress(pb::spotify::UserPlaylist, i, download_progress);
+      me->SendDownloadProgress(cpb::spotify::UserPlaylist, i, download_progress);
     }
   }
 
@@ -862,7 +862,7 @@
   sp_playlist_release(inbox);
 
   if (download_progress != -1) {
-    me->SendDownloadProgress(pb::spotify::Inbox, -1, download_progress);
+    me->SendDownloadProgress(cpb::spotify::Inbox, -1, download_progress);
   }
 
   sp_playlist* starred = sp_session_starred_create(session);
@@ -870,14 +870,14 @@
   sp_playlist_release(starred);
 
   if (download_progress != -1) {
-    me->SendDownloadProgress(pb::spotify::Starred, -1, download_progress);
+    me->SendDownloadProgress(cpb::spotify::Starred, -1, download_progress);
   }
 }
 
-void SpotifyClient::SendDownloadProgress(pb::spotify::PlaylistType type,
+void SpotifyClient::SendDownloadProgress(cpb::spotify::PlaylistType type,
                                          int index, int download_progress) {
-  pb::spotify::Message message;
-  pb::spotify::SyncPlaylistProgress* progress =
+  cpb::spotify::Message message;
+  cpb::spotify::SyncPlaylistProgress* progress =
       message.mutable_sync_playlist_progress();
   progress->mutable_request()->set_type(type);
   if (index != -1) {
@@ -903,7 +903,7 @@
   return -1;
 }
 
-void SpotifyClient::StartPlayback(const pb::spotify::PlaybackRequest& req) {
+void SpotifyClient::StartPlayback(const cpb::spotify::PlaybackRequest& req) {
   // Get a link object from the URI
   sp_link* link = sp_link_create_from_string(req.track_uri().c_str());
   if (!link) {
@@ -970,8 +970,8 @@
 }
 
 void SpotifyClient::SendPlaybackError(const QString& error) {
-  pb::spotify::Message message;
-  pb::spotify::PlaybackError* msg = message.mutable_playback_error();
+  cpb::spotify::Message message;
+  cpb::spotify::PlaybackError* msg = message.mutable_playback_error();
 
   msg->set_error(DataCommaSizeFromQString(error));
   SendMessage(message);
@@ -984,8 +984,8 @@
                   << kSpotifyImageIDSize << "bytes):" << id_b64;
 
     // Send an error response straight away
-    pb::spotify::Message message;
-    pb::spotify::ImageResponse* msg = message.mutable_image_response();
+    cpb::spotify::Message message;
+    cpb::spotify::ImageResponse* msg = message.mutable_image_response();
     msg->set_id(DataCommaSizeFromQString(id_b64));
     SendMessage(message);
     return;
@@ -1033,8 +1033,8 @@
   const void* data = sp_image_data(image, &size);
 
   // Send the response
-  pb::spotify::Message message;
-  pb::spotify::ImageResponse* msg = message.mutable_image_response();
+  cpb::spotify::Message message;
+  cpb::spotify::ImageResponse* msg = message.mutable_image_response();
   msg->set_id(DataCommaSizeFromQString(req->id_b64_));
   if (data && size) {
     msg->set_data(data, size);
@@ -1086,8 +1086,8 @@
 
   QString uri = me->pending_album_browses_.take(result);
 
-  pb::spotify::Message message;
-  pb::spotify::BrowseAlbumResponse* msg =
+  cpb::spotify::Message message;
+  cpb::spotify::BrowseAlbumResponse* msg =
       message.mutable_browse_album_response();
 
   msg->set_uri(DataCommaSizeFromQString(uri));
@@ -1102,7 +1102,7 @@
 }
 
 void SpotifyClient::BrowseToplist(
-    const pb::spotify::BrowseToplistRequest& req) {
+    const cpb::spotify::BrowseToplistRequest& req) {
   sp_toplistbrowse* browse = sp_toplistbrowse_create(
       session_, SP_TOPLIST_TYPE_TRACKS,  // TODO: Support albums and artists.
       SP_TOPLIST_REGION_EVERYWHERE,      // TODO: Support other regions.
@@ -1110,7 +1110,7 @@
   pending_toplist_browses_[browse] = req;
 }
 
-void SpotifyClient::SetPaused(const pb::spotify::PauseRequest& req) {
+void SpotifyClient::SetPaused(const cpb::spotify::PauseRequest& req) {
   sp_session_player_play(session_, !req.paused());
 }
 
@@ -1125,11 +1125,11 @@
     return;
   }
 
-  const pb::spotify::BrowseToplistRequest& request =
+  const cpb::spotify::BrowseToplistRequest& request =
       me->pending_toplist_browses_.take(result);
 
-  pb::spotify::Message message;
-  pb::spotify::BrowseToplistResponse* msg =
+  cpb::spotify::Message message;
+  cpb::spotify::BrowseToplistResponse* msg =
       message.mutable_browse_toplist_response();
   msg->mutable_request()->CopyFrom(request);
 
@@ -1143,7 +1143,7 @@
 }
 
 void SpotifyClient::DeviceClosed() {
-  AbstractMessageHandler<pb::spotify::Message>::DeviceClosed();
+  AbstractMessageHandler<cpb::spotify::Message>::DeviceClosed();
 
   qApp->exit();
 }
diff -ur ext/clementine-spotifyblob/spotifyclient.h ext/clementine-spotifyblob/spotifyclient.h
--- a/ext/clementine-spotifyblob/spotifyclient.h	2020-09-23 22:34:08.000000000 -0400
+++ b/ext/clementine-spotifyblob/spotifyclient.h	2021-02-19 12:03:48.233473023 -0500
@@ -35,7 +35,7 @@
 class MediaPipeline;
 class ResponseMessage;
 
-class SpotifyClient : public AbstractMessageHandler<pb::spotify::Message> {
+class SpotifyClient : public AbstractMessageHandler<cpb::spotify::Message> {
   Q_OBJECT
 
  public:
@@ -48,7 +48,7 @@
   void Init(quint16 port);
 
  protected:
-  void MessageArrived(const pb::spotify::Message& message);
+  void MessageArrived(const cpb::spotify::Message& message);
   void DeviceClosed();
 
  private slots:
@@ -56,7 +56,7 @@
 
  private:
   void SendLoginCompleted(bool success, const QString& error,
-                          pb::spotify::LoginResponse_Error error_code);
+                          cpb::spotify::LoginResponse_Error error_code);
   void SendPlaybackError(const QString& error);
   void SendSearchResponse(sp_search* result);
 
@@ -118,40 +118,40 @@
       ToplistBrowseComplete(sp_toplistbrowse* result, void* userdata);
 
   // Request handlers.
-  void Login(const pb::spotify::LoginRequest& req);
-  void Search(const pb::spotify::SearchRequest& req);
-  void LoadPlaylist(const pb::spotify::LoadPlaylistRequest& req);
-  void SyncPlaylist(const pb::spotify::SyncPlaylistRequest& req);
-  void AddTracksToPlaylist(const pb::spotify::AddTracksToPlaylistRequest& req);
+  void Login(const cpb::spotify::LoginRequest& req);
+  void Search(const cpb::spotify::SearchRequest& req);
+  void LoadPlaylist(const cpb::spotify::LoadPlaylistRequest& req);
+  void SyncPlaylist(const cpb::spotify::SyncPlaylistRequest& req);
+  void AddTracksToPlaylist(const cpb::spotify::AddTracksToPlaylistRequest& req);
   void RemoveTracksFromPlaylist(
-      const pb::spotify::RemoveTracksFromPlaylistRequest& req);
-  void StartPlayback(const pb::spotify::PlaybackRequest& req);
+      const cpb::spotify::RemoveTracksFromPlaylistRequest& req);
+  void StartPlayback(const cpb::spotify::PlaybackRequest& req);
   void Seek(qint64 offset_nsec);
   void LoadImage(const QString& id_b64);
   void BrowseAlbum(const QString& uri);
-  void BrowseToplist(const pb::spotify::BrowseToplistRequest& req);
-  void SetPlaybackSettings(const pb::spotify::PlaybackSettings& req);
-  void SetPaused(const pb::spotify::PauseRequest& req);
+  void BrowseToplist(const cpb::spotify::BrowseToplistRequest& req);
+  void SetPlaybackSettings(const cpb::spotify::PlaybackSettings& req);
+  void SetPaused(const cpb::spotify::PauseRequest& req);
 
   void SendPlaylistList();
 
-  void ConvertTrack(sp_track* track, pb::spotify::Track* pb);
-  void ConvertAlbum(sp_album* album, pb::spotify::Track* pb);
-  void ConvertAlbumBrowse(sp_albumbrowse* browse, pb::spotify::Track* pb);
+  void ConvertTrack(sp_track* track, cpb::spotify::Track* pb);
+  void ConvertAlbum(sp_album* album, cpb::spotify::Track* pb);
+  void ConvertAlbumBrowse(sp_albumbrowse* browse, cpb::spotify::Track* pb);
 
   // Gets the appropriate sp_playlist* but does not load it.
-  sp_playlist* GetPlaylist(pb::spotify::PlaylistType type, int user_index);
+  sp_playlist* GetPlaylist(cpb::spotify::PlaylistType type, int user_index);
 
  private:
   struct PendingLoadPlaylist {
-    pb::spotify::LoadPlaylistRequest request_;
+    cpb::spotify::LoadPlaylistRequest request_;
     sp_playlist* playlist_;
     QList<sp_track*> tracks_;
     bool offline_sync;
   };
 
   struct PendingPlaybackRequest {
-    pb::spotify::PlaybackRequest request_;
+    cpb::spotify::PlaybackRequest request_;
     sp_link* link_;
     sp_track* track_;
 
@@ -170,7 +170,7 @@
   void TryPlaybackAgain(const PendingPlaybackRequest& req);
   void TryImageAgain(sp_image* image);
   int GetDownloadProgress(sp_playlist* playlist);
-  void SendDownloadProgress(pb::spotify::PlaylistType type, int index,
+  void SendDownloadProgress(cpb::spotify::PlaylistType type, int index,
                             int download_progress);
 
   QByteArray api_key_;
@@ -190,9 +190,9 @@
   QList<PendingPlaybackRequest> pending_playback_requests_;
   QList<PendingImageRequest> pending_image_requests_;
   QMap<sp_image*, int> image_callbacks_registered_;
-  QMap<sp_search*, pb::spotify::SearchRequest> pending_searches_;
+  QMap<sp_search*, cpb::spotify::SearchRequest> pending_searches_;
   QMap<sp_albumbrowse*, QString> pending_album_browses_;
-  QMap<sp_toplistbrowse*, pb::spotify::BrowseToplistRequest>
+  QMap<sp_toplistbrowse*, cpb::spotify::BrowseToplistRequest>
       pending_toplist_browses_;
 
   QMap<sp_search*, QList<sp_albumbrowse*>> pending_search_album_browses_;
diff -ur ext/clementine-tagreader/tagreaderworker.cpp ext/clementine-tagreader/tagreaderworker.cpp
--- a/ext/clementine-tagreader/tagreaderworker.cpp	2020-09-23 22:34:08.000000000 -0400
+++ b/ext/clementine-tagreader/tagreaderworker.cpp	2021-02-19 12:03:48.234473027 -0500
@@ -25,10 +25,10 @@
 #include <QUrl>
 
 TagReaderWorker::TagReaderWorker(QIODevice* socket, QObject* parent)
-    : AbstractMessageHandler<pb::tagreader::Message>(socket, parent) {}
+    : AbstractMessageHandler<cpb::tagreader::Message>(socket, parent) {}
 
-void TagReaderWorker::MessageArrived(const pb::tagreader::Message& message) {
-  pb::tagreader::Message reply;
+void TagReaderWorker::MessageArrived(const cpb::tagreader::Message& message) {
+  cpb::tagreader::Message reply;
 
 #if 0
   // Crash every few requests
@@ -68,7 +68,7 @@
                                                          data.size());
   } else if (message.has_read_cloud_file_request()) {
 #ifdef HAVE_GOOGLE_DRIVE
-    const pb::tagreader::ReadCloudFileRequest& req =
+    const cpb::tagreader::ReadCloudFileRequest& req =
         message.read_cloud_file_request();
     if (!tag_reader_.ReadCloudFile(
             QUrl::fromEncoded(QByteArray(req.download_url().data(),
@@ -86,7 +86,7 @@
 }
 
 void TagReaderWorker::DeviceClosed() {
-  AbstractMessageHandler<pb::tagreader::Message>::DeviceClosed();
+  AbstractMessageHandler<cpb::tagreader::Message>::DeviceClosed();
 
   qApp->exit();
 }
diff -ur ext/clementine-tagreader/tagreaderworker.h ext/clementine-tagreader/tagreaderworker.h
--- a/ext/clementine-tagreader/tagreaderworker.h	2020-09-23 22:34:08.000000000 -0400
+++ b/ext/clementine-tagreader/tagreaderworker.h	2021-02-19 12:03:48.234473027 -0500
@@ -23,12 +23,12 @@
 #include "tagreadermessages.pb.h"
 #include "core/messagehandler.h"
 
-class TagReaderWorker : public AbstractMessageHandler<pb::tagreader::Message> {
+class TagReaderWorker : public AbstractMessageHandler<cpb::tagreader::Message> {
  public:
   TagReaderWorker(QIODevice* socket, QObject* parent = NULL);
 
  protected:
-  void MessageArrived(const pb::tagreader::Message& message);
+  void MessageArrived(const cpb::tagreader::Message& message);
   void DeviceClosed();
 
  private:
diff -ur ext/libclementine-remote/remotecontrolmessages.proto ext/libclementine-remote/remotecontrolmessages.proto
--- a/ext/libclementine-remote/remotecontrolmessages.proto	2020-09-23 22:34:08.000000000 -0400
+++ b/ext/libclementine-remote/remotecontrolmessages.proto	2021-02-19 12:03:48.234473027 -0500
@@ -20,7 +20,7 @@
 
 syntax = "proto2";
 
-package pb.remote;
+package cpb.remote;
 
 // The supported message types
 enum MsgType {
diff -ur ext/libclementine-spotifyblob/spotifymessages.proto ext/libclementine-spotifyblob/spotifymessages.proto
--- a/ext/libclementine-spotifyblob/spotifymessages.proto	2020-09-23 22:34:08.000000000 -0400
+++ b/ext/libclementine-spotifyblob/spotifymessages.proto	2021-02-19 12:03:48.234473027 -0500
@@ -20,7 +20,7 @@
 
 syntax = "proto2";
 
-package pb.spotify;
+package cpb.spotify;
 
 message LoginRequest {
   required string username = 1;
diff -ur ext/libclementine-tagreader/gmereader.cpp ext/libclementine-tagreader/gmereader.cpp
--- a/ext/libclementine-tagreader/gmereader.cpp	2020-09-23 22:34:08.000000000 -0400
+++ b/ext/libclementine-tagreader/gmereader.cpp	2021-02-19 12:03:48.234473027 -0500
@@ -20,7 +20,7 @@
 }
 
 void GME::ReadFile(const QFileInfo& file_info,
-                   pb::tagreader::SongMetadata* song_info) {
+                   cpb::tagreader::SongMetadata* song_info) {
   if (file_info.completeSuffix().endsWith("spc"))
     SPC::Read(file_info, song_info);
   if (file_info.completeSuffix().endsWith("vgm"))
@@ -28,7 +28,7 @@
 }
 
 void GME::SPC::Read(const QFileInfo& file_info,
-                    pb::tagreader::SongMetadata* song_info) {
+                    cpb::tagreader::SongMetadata* song_info) {
   QFile file(file_info.filePath());
   if (!file.open(QIODevice::ReadOnly)) return;
 
@@ -137,7 +137,7 @@
   }
 
   song_info->set_valid(true);
-  song_info->set_type(pb::tagreader::SongMetadata_Type_SPC);
+  song_info->set_type(cpb::tagreader::SongMetadata_Type_SPC);
 }
 
 qint16 GME::SPC::GetNextMemAddressAlign32bit(qint16 input) {
@@ -157,7 +157,7 @@
 }
 
 void GME::VGM::Read(const QFileInfo& file_info,
-                    pb::tagreader::SongMetadata* song_info) {
+                    cpb::tagreader::SongMetadata* song_info) {
   QFile file(file_info.filePath());
   if (!file.open(QIODevice::ReadOnly)) return;
 
@@ -206,7 +206,7 @@
   song_info->set_year(strings[8].left(4).toInt());
   song_info->set_length_nanosec(length * kNsecPerMsec);
   song_info->set_valid(true);
-  song_info->set_type(pb::tagreader::SongMetadata_Type_VGM);
+  song_info->set_type(cpb::tagreader::SongMetadata_Type_VGM);
 }
 
 bool GME::VGM::GetPlaybackLength(const QByteArray& sample_count_bytes,
diff -ur ext/libclementine-tagreader/gmereader.h ext/libclementine-tagreader/gmereader.h
--- a/ext/libclementine-tagreader/gmereader.h	2020-09-23 22:34:08.000000000 -0400
+++ b/ext/libclementine-tagreader/gmereader.h	2021-02-19 12:03:48.235473030 -0500
@@ -10,7 +10,7 @@
 namespace GME {
 bool IsSupportedFormat(const QFileInfo& file_info);
 void ReadFile(const QFileInfo& file_info,
-              pb::tagreader::SongMetadata* song_info);
+              cpb::tagreader::SongMetadata* song_info);
 
 namespace SPC {
 /* SPC SPEC:
@@ -42,7 +42,7 @@
 
 enum xID6_TYPE { Length = 0x0, String = 0x1, Integer = 0x4 };
 
-void Read(const QFileInfo& file_info, pb::tagreader::SongMetadata* song_info);
+void Read(const QFileInfo& file_info, cpb::tagreader::SongMetadata* song_info);
 qint16 GetNextMemAddressAlign32bit(qint16 input);
 quint64 ConvertSPCStringToNum(const QByteArray& arr);
 }  // namespace SPC
@@ -58,7 +58,7 @@
 const int SAMPLE_TIMEBASE = 44100;
 const int GST_GME_LOOP_TIME_MS = 8000;
 
-void Read(const QFileInfo& file_info, pb::tagreader::SongMetadata* song_info);
+void Read(const QFileInfo& file_info, cpb::tagreader::SongMetadata* song_info);
 /* Takes in two QByteArrays, expected to be 4 bytes long. Desired length
  * is returned via output parameter out_length. Returns false on error. */
 bool GetPlaybackLength(const QByteArray& sample_count_bytes,
diff -ur ext/libclementine-tagreader/tagreader.cpp ext/libclementine-tagreader/tagreader.cpp
--- a/ext/libclementine-tagreader/tagreader.cpp	2020-09-23 22:34:08.000000000 -0400
+++ b/ext/libclementine-tagreader/tagreader.cpp	2021-02-19 12:03:48.235473030 -0500
@@ -143,7 +143,7 @@
 
 }  // namespace
 
-void TagReader::GuessArtistAndTitle(pb::tagreader::SongMetadata* song) const {
+void TagReader::GuessArtistAndTitle(cpb::tagreader::SongMetadata* song) const {
   QString artist = QString::fromStdString(song->artist());
   QString title = QString::fromStdString(song->title());
   const QString bn = QString::fromStdString(song->basefilename());
@@ -171,7 +171,7 @@
 }
 
 void TagReader::GuessAlbum(const QFileInfo& info,
-                           pb::tagreader::SongMetadata* song) const {
+                           cpb::tagreader::SongMetadata* song) const {
   QString album = QString::fromStdString(song->album());
   if (!album.isEmpty()) return;
   const QString str_dir = info.absoluteDir().absolutePath();
@@ -191,7 +191,7 @@
     : factory_(new TagLibFileRefFactory), kEmbeddedCover("(embedded)") {}
 
 void TagReader::ReadFile(const QString& filename,
-                         pb::tagreader::SongMetadata* song) const {
+                         cpb::tagreader::SongMetadata* song) const {
   const QByteArray url(QUrl::fromLocalFile(filename).toEncoded());
   const QFileInfo info(filename);
 
@@ -674,7 +674,7 @@
 }
 
 void TagReader::ParseFMPSFrame(const QString& name, const QString& value,
-                               pb::tagreader::SongMetadata* song) const {
+                               cpb::tagreader::SongMetadata* song) const {
   qLog(Debug) << "Parsing FMPSFrame" << name << ", " << value;
   FMPSParser parser;
   if (!parser.Parse(value) || parser.is_empty()) return;
@@ -717,7 +717,7 @@
 void TagReader::ParseOggTag(const TagLib::Ogg::FieldListMap& map,
                             const QTextCodec* codec, QString* disc,
                             QString* compilation,
-                            pb::tagreader::SongMetadata* song) const {
+                            cpb::tagreader::SongMetadata* song) const {
   if (!map["COMPOSER"].isEmpty())
     Decode(map["COMPOSER"].front(), codec, song->mutable_composer());
   if (!map["PERFORMER"].isEmpty())
@@ -774,7 +774,7 @@
 
 void TagReader::SetVorbisComments(
     TagLib::Ogg::XiphComment* vorbis_comments,
-    const pb::tagreader::SongMetadata& song) const {
+    const cpb::tagreader::SongMetadata& song) const {
   vorbis_comments->addField("COMPOSER",
                             StdStringToTaglibString(song.composer()), true);
   vorbis_comments->addField("PERFORMER",
@@ -810,7 +810,7 @@
 
 void TagReader::SetFMPSStatisticsVorbisComments(
     TagLib::Ogg::XiphComment* vorbis_comments,
-    const pb::tagreader::SongMetadata& song) const {
+    const cpb::tagreader::SongMetadata& song) const {
   if (song.playcount())
     vorbis_comments->addField("FMPS_PLAYCOUNT",
                               TagLib::String::number(song.playcount()), true);
@@ -822,54 +822,54 @@
 
 void TagReader::SetFMPSRatingVorbisComments(
     TagLib::Ogg::XiphComment* vorbis_comments,
-    const pb::tagreader::SongMetadata& song) const {
+    const cpb::tagreader::SongMetadata& song) const {
   vorbis_comments->addField(
       "FMPS_RATING", QStringToTaglibString(QString::number(song.rating())),
       true);
 }
 
-pb::tagreader::SongMetadata_Type TagReader::GuessFileType(
+cpb::tagreader::SongMetadata_Type TagReader::GuessFileType(
     TagLib::FileRef* fileref) const {
 #ifdef TAGLIB_WITH_ASF
   if (dynamic_cast<TagLib::ASF::File*>(fileref->file()))
-    return pb::tagreader::SongMetadata_Type_ASF;
+    return cpb::tagreader::SongMetadata_Type_ASF;
 #endif
   if (dynamic_cast<TagLib::FLAC::File*>(fileref->file()))
-    return pb::tagreader::SongMetadata_Type_FLAC;
+    return cpb::tagreader::SongMetadata_Type_FLAC;
 #ifdef TAGLIB_WITH_MP4
   if (dynamic_cast<TagLib::MP4::File*>(fileref->file()))
-    return pb::tagreader::SongMetadata_Type_MP4;
+    return cpb::tagreader::SongMetadata_Type_MP4;
 #endif
   if (dynamic_cast<TagLib::MPC::File*>(fileref->file()))
-    return pb::tagreader::SongMetadata_Type_MPC;
+    return cpb::tagreader::SongMetadata_Type_MPC;
   if (dynamic_cast<TagLib::MPEG::File*>(fileref->file()))
-    return pb::tagreader::SongMetadata_Type_MPEG;
+    return cpb::tagreader::SongMetadata_Type_MPEG;
   if (dynamic_cast<TagLib::Ogg::FLAC::File*>(fileref->file()))
-    return pb::tagreader::SongMetadata_Type_OGGFLAC;
+    return cpb::tagreader::SongMetadata_Type_OGGFLAC;
   if (dynamic_cast<TagLib::Ogg::Speex::File*>(fileref->file()))
-    return pb::tagreader::SongMetadata_Type_OGGSPEEX;
+    return cpb::tagreader::SongMetadata_Type_OGGSPEEX;
   if (dynamic_cast<TagLib::Ogg::Vorbis::File*>(fileref->file()))
-    return pb::tagreader::SongMetadata_Type_OGGVORBIS;
+    return cpb::tagreader::SongMetadata_Type_OGGVORBIS;
 #ifdef TAGLIB_HAS_OPUS
   if (dynamic_cast<TagLib::Ogg::Opus::File*>(fileref->file()))
-    return pb::tagreader::SongMetadata_Type_OGGOPUS;
+    return cpb::tagreader::SongMetadata_Type_OGGOPUS;
 #endif
   if (dynamic_cast<TagLib::RIFF::AIFF::File*>(fileref->file()))
-    return pb::tagreader::SongMetadata_Type_AIFF;
+    return cpb::tagreader::SongMetadata_Type_AIFF;
   if (dynamic_cast<TagLib::RIFF::WAV::File*>(fileref->file()))
-    return pb::tagreader::SongMetadata_Type_WAV;
+    return cpb::tagreader::SongMetadata_Type_WAV;
   if (dynamic_cast<TagLib::TrueAudio::File*>(fileref->file()))
-    return pb::tagreader::SongMetadata_Type_TRUEAUDIO;
+    return cpb::tagreader::SongMetadata_Type_TRUEAUDIO;
   if (dynamic_cast<TagLib::WavPack::File*>(fileref->file()))
-    return pb::tagreader::SongMetadata_Type_WAVPACK;
+    return cpb::tagreader::SongMetadata_Type_WAVPACK;
   if (dynamic_cast<TagLib::APE::File*>(fileref->file()))
-    return pb::tagreader::SongMetadata_Type_APE;
+    return cpb::tagreader::SongMetadata_Type_APE;
 
-  return pb::tagreader::SongMetadata_Type_UNKNOWN;
+  return cpb::tagreader::SongMetadata_Type_UNKNOWN;
 }
 
 bool TagReader::SaveFile(const QString& filename,
-                         const pb::tagreader::SongMetadata& song) const {
+                         const cpb::tagreader::SongMetadata& song) const {
   if (filename.isNull()) return false;
 
   qLog(Debug) << "Saving tags to" << filename;
@@ -986,7 +986,7 @@
 }
 
 bool TagReader::SaveSongStatisticsToFile(
-    const QString& filename, const pb::tagreader::SongMetadata& song) const {
+    const QString& filename, const cpb::tagreader::SongMetadata& song) const {
   if (filename.isNull()) return false;
 
   qLog(Debug) << "Saving song statistics tags to" << filename;
@@ -1083,7 +1083,7 @@
 }
 
 bool TagReader::SaveSongRatingToFile(
-    const QString& filename, const pb::tagreader::SongMetadata& song) const {
+    const QString& filename, const cpb::tagreader::SongMetadata& song) const {
   if (filename.isNull()) return false;
 
   qLog(Debug) << "Saving song rating tags to" << filename;
@@ -1427,7 +1427,7 @@
 bool TagReader::ReadCloudFile(const QUrl& download_url, const QString& title,
                               int size, const QString& mime_type,
                               const QString& authorisation_header,
-                              pb::tagreader::SongMetadata* song) const {
+                              cpb::tagreader::SongMetadata* song) const {
   qLog(Debug) << "Loading tags from" << title;
 
   std::unique_ptr<CloudStream> stream(
@@ -1488,7 +1488,7 @@
       song->set_year(tag->tag()->year());
     }
 
-    song->set_type(pb::tagreader::SongMetadata_Type_STREAM);
+    song->set_type(cpb::tagreader::SongMetadata_Type_STREAM);
 
     if (tag->audioProperties()) {
       song->set_length_nanosec(tag->audioProperties()->length() * kNsecPerSec);
diff -ur ext/libclementine-tagreader/tagreader.h ext/libclementine-tagreader/tagreader.h
--- a/ext/libclementine-tagreader/tagreader.h	2020-09-23 22:34:08.000000000 -0400
+++ b/ext/libclementine-tagreader/tagreader.h	2021-02-19 12:03:48.235473030 -0500
@@ -57,16 +57,16 @@
   TagReader();
 
   void ReadFile(const QString& filename,
-                pb::tagreader::SongMetadata* song) const;
+                cpb::tagreader::SongMetadata* song) const;
   bool SaveFile(const QString& filename,
-                const pb::tagreader::SongMetadata& song) const;
+                const cpb::tagreader::SongMetadata& song) const;
   // Returns false if something went wrong; returns true otherwise (might
   // returns true if the file exists but nothing has been written inside because
   // statistics tag format is not supported for this kind of file)
   bool SaveSongStatisticsToFile(const QString& filename,
-                                const pb::tagreader::SongMetadata& song) const;
+                                const cpb::tagreader::SongMetadata& song) const;
   bool SaveSongRatingToFile(const QString& filename,
-                            const pb::tagreader::SongMetadata& song) const;
+                            const cpb::tagreader::SongMetadata& song) const;
 
   bool IsMediaFile(const QString& filename) const;
   QByteArray LoadEmbeddedArt(const QString& filename) const;
@@ -74,7 +74,7 @@
 #ifdef HAVE_GOOGLE_DRIVE
   bool ReadCloudFile(const QUrl& download_url, const QString& title, int size,
                      const QString& mime_type, const QString& access_token,
-                     pb::tagreader::SongMetadata* song) const;
+                     cpb::tagreader::SongMetadata* song) const;
 #endif  // HAVE_GOOGLE_DRIVE
 
   static void Decode(const TagLib::String& tag, const QTextCodec* codec,
@@ -83,23 +83,23 @@
                      std::string* output);
 
   void ParseFMPSFrame(const QString& name, const QString& value,
-                      pb::tagreader::SongMetadata* song) const;
+                      cpb::tagreader::SongMetadata* song) const;
   void ParseOggTag(const TagLib::Ogg::FieldListMap& map,
                    const QTextCodec* codec, QString* disc, QString* compilation,
-                   pb::tagreader::SongMetadata* song) const;
+                   cpb::tagreader::SongMetadata* song) const;
   void SetVorbisComments(TagLib::Ogg::XiphComment* vorbis_comments,
-                         const pb::tagreader::SongMetadata& song) const;
+                         const cpb::tagreader::SongMetadata& song) const;
   void SetFMPSStatisticsVorbisComments(
       TagLib::Ogg::XiphComment* vorbis_comments,
-      const pb::tagreader::SongMetadata& song) const;
+      const cpb::tagreader::SongMetadata& song) const;
   void SetFMPSRatingVorbisComments(
       TagLib::Ogg::XiphComment* vorbis_comments,
-      const pb::tagreader::SongMetadata& song) const;
+      const cpb::tagreader::SongMetadata& song) const;
 
-  void GuessArtistAndTitle(pb::tagreader::SongMetadata* song) const;
-  void GuessAlbum(const QFileInfo &info, pb::tagreader::SongMetadata* song) const;
+  void GuessArtistAndTitle(cpb::tagreader::SongMetadata* song) const;
+  void GuessAlbum(const QFileInfo &info, cpb::tagreader::SongMetadata* song) const;
 
-  pb::tagreader::SongMetadata_Type GuessFileType(
+  cpb::tagreader::SongMetadata_Type GuessFileType(
       TagLib::FileRef* fileref) const;
 
   void SetUserTextFrame(const QString& description, const QString& value,
diff -ur ext/libclementine-tagreader/tagreadermessages.proto ext/libclementine-tagreader/tagreadermessages.proto
--- a/ext/libclementine-tagreader/tagreadermessages.proto	2020-09-23 22:34:08.000000000 -0400
+++ b/ext/libclementine-tagreader/tagreadermessages.proto	2021-02-19 12:03:48.235473030 -0500
@@ -1,6 +1,6 @@
 syntax = "proto2";
 
-package pb.tagreader;
+package cpb.tagreader;
 
 message SongMetadata {
   enum Type {
diff -ur src/core/song.cpp src/core/song.cpp
--- a/src/core/song.cpp	2020-09-23 22:34:08.000000000 -0400
+++ b/src/core/song.cpp	2021-02-19 12:03:48.236473033 -0500
@@ -526,7 +526,7 @@
   return codec->toUnicode(tag.toUtf8());
 }
 
-void Song::InitFromProtobuf(const pb::tagreader::SongMetadata& pb) {
+void Song::InitFromProtobuf(const cpb::tagreader::SongMetadata& pb) {
   d->init_from_file_ = true;
   d->valid_ = pb.valid();
   d->title_ = QStringFromStdString(pb.title());
@@ -575,7 +575,7 @@
   InitArtManual();
 }
 
-void Song::ToProtobuf(pb::tagreader::SongMetadata* pb) const {
+void Song::ToProtobuf(cpb::tagreader::SongMetadata* pb) const {
   const QByteArray url(d->url_.toEncoded());
 
   pb->set_valid(d->valid_);
@@ -610,7 +610,7 @@
   pb->set_filesize(d->filesize_);
   pb->set_suspicious_tags(d->suspicious_tags_);
   pb->set_art_automatic(DataCommaSizeFromQString(d->art_automatic_));
-  pb->set_type(static_cast<pb::tagreader::SongMetadata_Type>(d->filetype_));
+  pb->set_type(static_cast<cpb::tagreader::SongMetadata_Type>(d->filetype_));
 }
 
 void Song::InitFromQuery(const SqlRow& q, bool reliable_metadata, int col) {
diff -ur src/core/song.h src/core/song.h
--- a/src/core/song.h	2020-09-23 22:34:08.000000000 -0400
+++ b/src/core/song.h	2021-02-19 12:04:03.092521906 -0500
@@ -37,11 +37,11 @@
 #include "config.h"
 #include "engines/engine_fwd.h"
 
-namespace pb {
+namespace cpb {
 namespace tagreader {
 class SongMetadata;
 }  // namespace tagreader
-}  // namespace pb
+}  // namespace cpb
 
 class QSqlQuery;
 class QUrl;
@@ -123,7 +123,7 @@
             qint64 length_nanosec);
   void Init(const QString& title, const QString& artist, const QString& album,
             qint64 beginning, qint64 end);
-  void InitFromProtobuf(const pb::tagreader::SongMetadata& pb);
+  void InitFromProtobuf(const cpb::tagreader::SongMetadata& pb);
   void InitFromQuery(const SqlRow& query, bool reliable_metadata, int col = 0);
   void InitFromFilePartial(
       const QString& filename);  // Just store the filename: incomplete but fast
@@ -159,7 +159,7 @@
   void ToLastFM(lastfm::Track* track, bool prefer_album_artist) const;
 #endif
   void ToXesam(QVariantMap* map) const;
-  void ToProtobuf(pb::tagreader::SongMetadata* pb) const;
+  void ToProtobuf(cpb::tagreader::SongMetadata* pb) const;
 
   // Simple accessors
   bool is_valid() const;
diff -ur src/core/tagreaderclient.cpp src/core/tagreaderclient.cpp
--- a/src/core/tagreaderclient.cpp	2020-09-23 22:34:08.000000000 -0400
+++ b/src/core/tagreaderclient.cpp	2021-02-19 12:03:48.236473033 -0500
@@ -58,8 +58,8 @@
 }
 
 TagReaderReply* TagReaderClient::ReadFile(const QString& filename) {
-  pb::tagreader::Message message;
-  pb::tagreader::ReadFileRequest* req = message.mutable_read_file_request();
+  cpb::tagreader::Message message;
+  cpb::tagreader::ReadFileRequest* req = message.mutable_read_file_request();
 
   req->set_filename(DataCommaSizeFromQString(filename));
 
@@ -68,8 +68,8 @@
 
 TagReaderReply* TagReaderClient::SaveFile(const QString& filename,
                                           const Song& metadata) {
-  pb::tagreader::Message message;
-  pb::tagreader::SaveFileRequest* req = message.mutable_save_file_request();
+  cpb::tagreader::Message message;
+  cpb::tagreader::SaveFileRequest* req = message.mutable_save_file_request();
 
   req->set_filename(DataCommaSizeFromQString(filename));
   metadata.ToProtobuf(req->mutable_metadata());
@@ -78,8 +78,8 @@
 }
 
 TagReaderReply* TagReaderClient::UpdateSongStatistics(const Song& metadata) {
-  pb::tagreader::Message message;
-  pb::tagreader::SaveSongStatisticsToFileRequest* req =
+  cpb::tagreader::Message message;
+  cpb::tagreader::SaveSongStatisticsToFileRequest* req =
       message.mutable_save_song_statistics_to_file_request();
 
   req->set_filename(DataCommaSizeFromQString(metadata.url().toLocalFile()));
@@ -96,8 +96,8 @@
 }
 
 TagReaderReply* TagReaderClient::UpdateSongRating(const Song& metadata) {
-  pb::tagreader::Message message;
-  pb::tagreader::SaveSongRatingToFileRequest* req =
+  cpb::tagreader::Message message;
+  cpb::tagreader::SaveSongRatingToFileRequest* req =
       message.mutable_save_song_rating_to_file_request();
 
   req->set_filename(DataCommaSizeFromQString(metadata.url().toLocalFile()));
@@ -114,8 +114,8 @@
 }
 
 TagReaderReply* TagReaderClient::IsMediaFile(const QString& filename) {
-  pb::tagreader::Message message;
-  pb::tagreader::IsMediaFileRequest* req =
+  cpb::tagreader::Message message;
+  cpb::tagreader::IsMediaFileRequest* req =
       message.mutable_is_media_file_request();
 
   req->set_filename(DataCommaSizeFromQString(filename));
@@ -124,8 +124,8 @@
 }
 
 TagReaderReply* TagReaderClient::LoadEmbeddedArt(const QString& filename) {
-  pb::tagreader::Message message;
-  pb::tagreader::LoadEmbeddedArtRequest* req =
+  cpb::tagreader::Message message;
+  cpb::tagreader::LoadEmbeddedArtRequest* req =
       message.mutable_load_embedded_art_request();
 
   req->set_filename(DataCommaSizeFromQString(filename));
@@ -136,8 +136,8 @@
 TagReaderReply* TagReaderClient::ReadCloudFile(
     const QUrl& download_url, const QString& title, int size,
     const QString& mime_type, const QString& authorisation_header) {
-  pb::tagreader::Message message;
-  pb::tagreader::ReadCloudFileRequest* req =
+  cpb::tagreader::Message message;
+  cpb::tagreader::ReadCloudFileRequest* req =
       message.mutable_read_cloud_file_request();
 
   const QString url_string = download_url.toEncoded();
diff -ur src/core/tagreaderclient.h src/core/tagreaderclient.h
--- a/src/core/tagreaderclient.h	2020-09-23 22:34:08.000000000 -0400
+++ b/src/core/tagreaderclient.h	2021-02-19 12:03:48.236473033 -0500
@@ -37,7 +37,7 @@
  public:
   explicit TagReaderClient(QObject* parent = nullptr);
 
-  typedef AbstractMessageHandler<pb::tagreader::Message> HandlerType;
+  typedef AbstractMessageHandler<cpb::tagreader::Message> HandlerType;
   typedef HandlerType::ReplyType ReplyType;
 
   static const char* kWorkerExecutableName;
@@ -78,7 +78,7 @@
   static TagReaderClient* sInstance;
 
   WorkerPool<HandlerType>* worker_pool_;
-  QList<pb::tagreader::Message> message_queue_;
+  QList<cpb::tagreader::Message> message_queue_;
 };
 
 typedef TagReaderClient::ReplyType TagReaderReply;
diff -ur src/globalsearch/spotifysearchprovider.cpp src/globalsearch/spotifysearchprovider.cpp
--- a/src/globalsearch/spotifysearchprovider.cpp	2020-09-23 22:34:08.000000000 -0400
+++ b/src/globalsearch/spotifysearchprovider.cpp	2021-02-19 12:03:48.236473033 -0500
@@ -49,16 +49,16 @@
   if (!service_->IsBlobInstalled()) return nullptr;
 
   server_ = service_->server();
-  connect(server_, SIGNAL(SearchResults(pb::spotify::SearchResponse)),
-          SLOT(SearchFinishedSlot(pb::spotify::SearchResponse)));
+  connect(server_, SIGNAL(SearchResults(cpb::spotify::SearchResponse)),
+          SLOT(SearchFinishedSlot(cpb::spotify::SearchResponse)));
   connect(server_, SIGNAL(ImageLoaded(QString, QImage)),
           SLOT(ArtLoadedSlot(QString, QImage)));
   connect(server_, SIGNAL(destroyed()), SLOT(ServerDestroyed()));
-  connect(server_, SIGNAL(StarredLoaded(pb::spotify::LoadPlaylistResponse)),
-          SLOT(SuggestionsLoaded(pb::spotify::LoadPlaylistResponse)));
+  connect(server_, SIGNAL(StarredLoaded(cpb::spotify::LoadPlaylistResponse)),
+          SLOT(SuggestionsLoaded(cpb::spotify::LoadPlaylistResponse)));
   connect(server_,
-          SIGNAL(ToplistBrowseResults(pb::spotify::BrowseToplistResponse)),
-          SLOT(SuggestionsLoaded(pb::spotify::BrowseToplistResponse)));
+          SIGNAL(ToplistBrowseResults(cpb::spotify::BrowseToplistResponse)),
+          SLOT(SuggestionsLoaded(cpb::spotify::BrowseToplistResponse)));
 
   return server_;
 }
@@ -82,7 +82,7 @@
 }
 
 void SpotifySearchProvider::SearchFinishedSlot(
-    const pb::spotify::SearchResponse& response) {
+    const cpb::spotify::SearchResponse& response) {
   QString query_string = QString::fromUtf8(response.request().query().c_str());
   QMap<QString, PendingState>::iterator it = queries_.find(query_string);
   if (it == queries_.end()) return;
@@ -107,7 +107,7 @@
   ResultList ret;
 
   for (int i = 0; i < response.album_size(); ++i) {
-    const pb::spotify::Album& album = response.album(i);
+    const cpb::spotify::Album& album = response.album(i);
 
     QHash<QString, int> artist_count;
     QString majority_artist;
@@ -153,7 +153,7 @@
   }
 
   for (int i = 0; i < response.result_size(); ++i) {
-    const pb::spotify::Track& track = response.result(i);
+    const cpb::spotify::Track& track = response.result(i);
 
     // Check this track/album against tracks we've already seen
     // in the album results, and skip if it's a duplicate
@@ -211,7 +211,7 @@
 }
 
 void SpotifySearchProvider::AddSuggestionFromTrack(
-    const pb::spotify::Track& track) {
+    const cpb::spotify::Track& track) {
   if (!track.title().empty()) {
     suggestions_.insert(QString::fromUtf8(track.title().c_str()));
   }
@@ -226,7 +226,7 @@
 }
 
 void SpotifySearchProvider::AddSuggestionFromAlbum(
-    const pb::spotify::Album& album) {
+    const cpb::spotify::Album& album) {
   AddSuggestionFromTrack(album.metadata());
   for (int i = 0; i < album.track_size(); ++i) {
     AddSuggestionFromTrack(album.track(i));
@@ -234,14 +234,14 @@
 }
 
 void SpotifySearchProvider::SuggestionsLoaded(
-    const pb::spotify::LoadPlaylistResponse& playlist) {
+    const cpb::spotify::LoadPlaylistResponse& playlist) {
   for (int i = 0; i < playlist.track_size(); ++i) {
     AddSuggestionFromTrack(playlist.track(i));
   }
 }
 
 void SpotifySearchProvider::SuggestionsLoaded(
-    const pb::spotify::BrowseToplistResponse& response) {
+    const cpb::spotify::BrowseToplistResponse& response) {
   for (int i = 0; i < response.track_size(); ++i) {
     AddSuggestionFromTrack(response.track(i));
   }
diff -ur src/globalsearch/spotifysearchprovider.h src/globalsearch/spotifysearchprovider.h
--- a/src/globalsearch/spotifysearchprovider.h	2020-09-23 22:34:08.000000000 -0400
+++ b/src/globalsearch/spotifysearchprovider.h	2021-02-19 12:03:48.237473037 -0500
@@ -41,17 +41,17 @@
 
  private slots:
   void ServerDestroyed();
-  void SearchFinishedSlot(const pb::spotify::SearchResponse& response);
+  void SearchFinishedSlot(const cpb::spotify::SearchResponse& response);
   void ArtLoadedSlot(const QString& id, const QImage& image);
-  void SuggestionsLoaded(const pb::spotify::LoadPlaylistResponse& response);
-  void SuggestionsLoaded(const pb::spotify::BrowseToplistResponse& response);
+  void SuggestionsLoaded(const cpb::spotify::LoadPlaylistResponse& response);
+  void SuggestionsLoaded(const cpb::spotify::BrowseToplistResponse& response);
 
  private:
   SpotifyServer* server();
 
   void LoadSuggestions();
-  void AddSuggestionFromTrack(const pb::spotify::Track& track);
-  void AddSuggestionFromAlbum(const pb::spotify::Album& album);
+  void AddSuggestionFromTrack(const cpb::spotify::Track& track);
+  void AddSuggestionFromAlbum(const cpb::spotify::Album& album);
 
  private:
   SpotifyServer* server_;
diff -ur src/internet/core/cloudfileservice.cpp src/internet/core/cloudfileservice.cpp
--- a/src/internet/core/cloudfileservice.cpp	2020-09-23 22:34:08.000000000 -0400
+++ b/src/internet/core/cloudfileservice.cpp	2021-02-19 12:03:48.237473037 -0500
@@ -192,14 +192,14 @@
                                    indexing_task_max_);
   }
 
-  const pb::tagreader::ReadCloudFileResponse& message =
+  const cpb::tagreader::ReadCloudFileResponse& message =
       reply->message().read_cloud_file_response();
   if (!message.has_metadata() || !message.metadata().filesize()) {
     qLog(Debug) << "Failed to tag:" << metadata.url();
     return;
   }
 
-  pb::tagreader::SongMetadata metadata_pb;
+  cpb::tagreader::SongMetadata metadata_pb;
   metadata.ToProtobuf(&metadata_pb);
   metadata_pb.MergeFrom(message.metadata());
 
diff -ur src/internet/spotify/spotifyserver.cpp src/internet/spotify/spotifyserver.cpp
--- a/src/internet/spotify/spotifyserver.cpp	2020-09-23 22:34:08.000000000 -0400
+++ b/src/internet/spotify/spotifyserver.cpp	2021-02-19 12:03:48.237473037 -0500
@@ -31,7 +31,7 @@
 #include "spotifymessages.pb.h"
 
 SpotifyServer::SpotifyServer(QObject* parent)
-    : AbstractMessageHandler<pb::spotify::Message>(nullptr, parent),
+    : AbstractMessageHandler<cpb::spotify::Message>(nullptr, parent),
       server_(new QTcpServer(this)),
       logged_in_(false) {
   connect(server_, SIGNAL(newConnection()), SLOT(NewConnection()));
@@ -52,7 +52,7 @@
   qLog(Info) << "Connection from port" << socket->peerPort();
 
   // Send any login messages that were queued before the client connected
-  for (const pb::spotify::Message& message : queued_login_messages_) {
+  for (const cpb::spotify::Message& message : queued_login_messages_) {
     SendOrQueueMessage(message);
   }
   queued_login_messages_.clear();
@@ -61,10 +61,10 @@
   disconnect(server_, SIGNAL(newConnection()), this, 0);
 }
 
-void SpotifyServer::SendOrQueueMessage(const pb::spotify::Message& message) {
+void SpotifyServer::SendOrQueueMessage(const cpb::spotify::Message& message) {
   const bool is_login_message = message.has_login_request();
 
-  QList<pb::spotify::Message>* queue =
+  QList<cpb::spotify::Message>* queue =
       is_login_message ? &queued_login_messages_ : &queued_messages_;
 
   if (!device_ || (!is_login_message && !logged_in_)) {
@@ -75,11 +75,11 @@
 }
 
 void SpotifyServer::Login(const QString& username, const QString& password,
-                          pb::spotify::Bitrate bitrate,
+                          cpb::spotify::Bitrate bitrate,
                           bool volume_normalisation) {
-  pb::spotify::Message message;
+  cpb::spotify::Message message;
 
-  pb::spotify::LoginRequest* request = message.mutable_login_request();
+  cpb::spotify::LoginRequest* request = message.mutable_login_request();
   request->set_username(DataCommaSizeFromQString(username));
   if (!password.isEmpty()) {
     request->set_password(DataCommaSizeFromQString(password));
@@ -91,11 +91,11 @@
   SendOrQueueMessage(message);
 }
 
-void SpotifyServer::SetPlaybackSettings(pb::spotify::Bitrate bitrate,
+void SpotifyServer::SetPlaybackSettings(cpb::spotify::Bitrate bitrate,
                                         bool volume_normalisation) {
-  pb::spotify::Message message;
+  cpb::spotify::Message message;
 
-  pb::spotify::PlaybackSettings* request =
+  cpb::spotify::PlaybackSettings* request =
       message.mutable_set_playback_settings_request();
   request->set_bitrate(bitrate);
   request->set_volume_normalisation(volume_normalisation);
@@ -103,14 +103,14 @@
   SendOrQueueMessage(message);
 }
 
-void SpotifyServer::MessageArrived(const pb::spotify::Message& message) {
+void SpotifyServer::MessageArrived(const cpb::spotify::Message& message) {
   if (message.has_login_response()) {
-    const pb::spotify::LoginResponse& response = message.login_response();
+    const cpb::spotify::LoginResponse& response = message.login_response();
     logged_in_ = response.success();
 
     if (response.success()) {
       // Send any messages that were queued before the client logged in
-      for (const pb::spotify::Message& message : queued_messages_) {
+      for (const cpb::spotify::Message& message : queued_messages_) {
         SendOrQueueMessage(message);
       }
       queued_messages_.clear();
@@ -122,19 +122,19 @@
   } else if (message.has_playlists_updated()) {
     emit PlaylistsUpdated(message.playlists_updated());
   } else if (message.has_load_playlist_response()) {
-    const pb::spotify::LoadPlaylistResponse& response =
+    const cpb::spotify::LoadPlaylistResponse& response =
         message.load_playlist_response();
 
     switch (response.request().type()) {
-      case pb::spotify::Inbox:
+      case cpb::spotify::Inbox:
         emit InboxLoaded(response);
         break;
 
-      case pb::spotify::Starred:
+      case cpb::spotify::Starred:
         emit StarredLoaded(response);
         break;
 
-      case pb::spotify::UserPlaylist:
+      case cpb::spotify::UserPlaylist:
         emit UserPlaylistLoaded(response);
         break;
     }
@@ -143,7 +143,7 @@
   } else if (message.has_search_response()) {
     emit SearchResults(message.search_response());
   } else if (message.has_image_response()) {
-    const pb::spotify::ImageResponse& response = message.image_response();
+    const cpb::spotify::ImageResponse& response = message.image_response();
     const QString id = QStringFromStdString(response.id());
 
     if (response.has_data()) {
@@ -162,9 +162,9 @@
   }
 }
 
-void SpotifyServer::LoadPlaylist(pb::spotify::PlaylistType type, int index) {
-  pb::spotify::Message message;
-  pb::spotify::LoadPlaylistRequest* req =
+void SpotifyServer::LoadPlaylist(cpb::spotify::PlaylistType type, int index) {
+  cpb::spotify::Message message;
+  cpb::spotify::LoadPlaylistRequest* req =
       message.mutable_load_playlist_request();
 
   req->set_type(type);
@@ -175,10 +175,10 @@
   SendOrQueueMessage(message);
 }
 
-void SpotifyServer::SyncPlaylist(pb::spotify::PlaylistType type, int index,
+void SpotifyServer::SyncPlaylist(cpb::spotify::PlaylistType type, int index,
                                  bool offline) {
-  pb::spotify::Message message;
-  pb::spotify::SyncPlaylistRequest* req =
+  cpb::spotify::Message message;
+  cpb::spotify::SyncPlaylistRequest* req =
       message.mutable_sync_playlist_request();
   req->mutable_request()->set_type(type);
   if (index != -1) {
@@ -189,40 +189,40 @@
   SendOrQueueMessage(message);
 }
 
-void SpotifyServer::SyncInbox() { SyncPlaylist(pb::spotify::Inbox, -1, true); }
+void SpotifyServer::SyncInbox() { SyncPlaylist(cpb::spotify::Inbox, -1, true); }
 
 void SpotifyServer::SyncStarred() {
-  SyncPlaylist(pb::spotify::Starred, -1, true);
+  SyncPlaylist(cpb::spotify::Starred, -1, true);
 }
 
 void SpotifyServer::SyncUserPlaylist(int index) {
   Q_ASSERT(index >= 0);
-  SyncPlaylist(pb::spotify::UserPlaylist, index, true);
+  SyncPlaylist(cpb::spotify::UserPlaylist, index, true);
 }
 
-void SpotifyServer::LoadInbox() { LoadPlaylist(pb::spotify::Inbox); }
+void SpotifyServer::LoadInbox() { LoadPlaylist(cpb::spotify::Inbox); }
 
-void SpotifyServer::LoadStarred() { LoadPlaylist(pb::spotify::Starred); }
+void SpotifyServer::LoadStarred() { LoadPlaylist(cpb::spotify::Starred); }
 
 void SpotifyServer::LoadUserPlaylist(int index) {
   Q_ASSERT(index >= 0);
-  LoadPlaylist(pb::spotify::UserPlaylist, index);
+  LoadPlaylist(cpb::spotify::UserPlaylist, index);
 }
 
 void SpotifyServer::AddSongsToStarred(const QList<QUrl>& songs_urls) {
-  AddSongsToPlaylist(pb::spotify::Starred, songs_urls);
+  AddSongsToPlaylist(cpb::spotify::Starred, songs_urls);
 }
 
 void SpotifyServer::AddSongsToUserPlaylist(int playlist_index,
                                            const QList<QUrl>& songs_urls) {
-  AddSongsToPlaylist(pb::spotify::UserPlaylist, songs_urls, playlist_index);
+  AddSongsToPlaylist(cpb::spotify::UserPlaylist, songs_urls, playlist_index);
 }
 
 void SpotifyServer::AddSongsToPlaylist(
-    const pb::spotify::PlaylistType playlist_type,
+    const cpb::spotify::PlaylistType playlist_type,
     const QList<QUrl>& songs_urls, int playlist_index) {
-  pb::spotify::Message message;
-  pb::spotify::AddTracksToPlaylistRequest* req =
+  cpb::spotify::Message message;
+  cpb::spotify::AddTracksToPlaylistRequest* req =
       message.mutable_add_tracks_to_playlist();
   req->set_playlist_type(playlist_type);
   req->set_playlist_index(playlist_index);
@@ -234,23 +234,23 @@
 
 void SpotifyServer::RemoveSongsFromStarred(
     const QList<int>& songs_indices_to_remove) {
-  RemoveSongsFromPlaylist(pb::spotify::Starred, songs_indices_to_remove);
+  RemoveSongsFromPlaylist(cpb::spotify::Starred, songs_indices_to_remove);
 }
 
 void SpotifyServer::RemoveSongsFromUserPlaylist(
     int playlist_index, const QList<int>& songs_indices_to_remove) {
-  RemoveSongsFromPlaylist(pb::spotify::UserPlaylist, songs_indices_to_remove,
+  RemoveSongsFromPlaylist(cpb::spotify::UserPlaylist, songs_indices_to_remove,
                           playlist_index);
 }
 
 void SpotifyServer::RemoveSongsFromPlaylist(
-    const pb::spotify::PlaylistType playlist_type,
+    const cpb::spotify::PlaylistType playlist_type,
     const QList<int>& songs_indices_to_remove, int playlist_index) {
-  pb::spotify::Message message;
-  pb::spotify::RemoveTracksFromPlaylistRequest* req =
+  cpb::spotify::Message message;
+  cpb::spotify::RemoveTracksFromPlaylistRequest* req =
       message.mutable_remove_tracks_from_playlist();
   req->set_playlist_type(playlist_type);
-  if (playlist_type == pb::spotify::UserPlaylist) {
+  if (playlist_type == cpb::spotify::UserPlaylist) {
     req->set_playlist_index(playlist_index);
   }
   for (int song_index : songs_indices_to_remove) {
@@ -260,8 +260,8 @@
 }
 
 void SpotifyServer::StartPlayback(const QString& uri, quint16 port) {
-  pb::spotify::Message message;
-  pb::spotify::PlaybackRequest* req = message.mutable_playback_request();
+  cpb::spotify::Message message;
+  cpb::spotify::PlaybackRequest* req = message.mutable_playback_request();
 
   req->set_track_uri(DataCommaSizeFromQString(uri));
   req->set_media_port(port);
@@ -269,16 +269,16 @@
 }
 
 void SpotifyServer::Seek(qint64 offset_nsec) {
-  pb::spotify::Message message;
-  pb::spotify::SeekRequest* req = message.mutable_seek_request();
+  cpb::spotify::Message message;
+  cpb::spotify::SeekRequest* req = message.mutable_seek_request();
 
   req->set_offset_nsec(offset_nsec);
   SendOrQueueMessage(message);
 }
 
 void SpotifyServer::Search(const QString& text, int limit, int limit_album) {
-  pb::spotify::Message message;
-  pb::spotify::SearchRequest* req = message.mutable_search_request();
+  cpb::spotify::Message message;
+  cpb::spotify::SearchRequest* req = message.mutable_search_request();
 
   req->set_query(DataCommaSizeFromQString(text));
   req->set_limit(limit);
@@ -287,34 +287,34 @@
 }
 
 void SpotifyServer::LoadImage(const QString& id) {
-  pb::spotify::Message message;
-  pb::spotify::ImageRequest* req = message.mutable_image_request();
+  cpb::spotify::Message message;
+  cpb::spotify::ImageRequest* req = message.mutable_image_request();
 
   req->set_id(DataCommaSizeFromQString(id));
   SendOrQueueMessage(message);
 }
 
 void SpotifyServer::AlbumBrowse(const QString& uri) {
-  pb::spotify::Message message;
-  pb::spotify::BrowseAlbumRequest* req = message.mutable_browse_album_request();
+  cpb::spotify::Message message;
+  cpb::spotify::BrowseAlbumRequest* req = message.mutable_browse_album_request();
 
   req->set_uri(DataCommaSizeFromQString(uri));
   SendOrQueueMessage(message);
 }
 
 void SpotifyServer::LoadToplist() {
-  pb::spotify::Message message;
-  pb::spotify::BrowseToplistRequest* req =
+  cpb::spotify::Message message;
+  cpb::spotify::BrowseToplistRequest* req =
       message.mutable_browse_toplist_request();
-  req->set_type(pb::spotify::BrowseToplistRequest::Tracks);
-  req->set_region(pb::spotify::BrowseToplistRequest::Everywhere);
+  req->set_type(cpb::spotify::BrowseToplistRequest::Tracks);
+  req->set_region(cpb::spotify::BrowseToplistRequest::Everywhere);
 
   SendOrQueueMessage(message);
 }
 
 void SpotifyServer::SetPaused(const bool paused) {
-  pb::spotify::Message message;
-  pb::spotify::PauseRequest* req = message.mutable_pause_request();
+  cpb::spotify::Message message;
+  cpb::spotify::PauseRequest* req = message.mutable_pause_request();
   req->set_paused(paused);
   SendOrQueueMessage(message);
 }
diff -ur src/internet/spotify/spotifyserver.h src/internet/spotify/spotifyserver.h
--- a/src/internet/spotify/spotifyserver.h	2020-09-23 22:34:08.000000000 -0400
+++ b/src/internet/spotify/spotifyserver.h	2021-02-19 12:03:48.237473037 -0500
@@ -31,7 +31,7 @@
 class QTcpServer;
 class QTcpSocket;
 
-class SpotifyServer : public AbstractMessageHandler<pb::spotify::Message> {
+class SpotifyServer : public AbstractMessageHandler<cpb::spotify::Message> {
   Q_OBJECT
 
  public:
@@ -39,7 +39,7 @@
 
   void Init();
   void Login(const QString& username, const QString& password,
-             pb::spotify::Bitrate bitrate, bool volume_normalisation);
+             cpb::spotify::Bitrate bitrate, bool volume_normalisation);
 
   void LoadStarred();
   void SyncStarred();
@@ -56,7 +56,7 @@
   void Search(const QString& text, int limit, int limit_album = 0);
   void LoadImage(const QString& id);
   void AlbumBrowse(const QString& uri);
-  void SetPlaybackSettings(pb::spotify::Bitrate bitrate,
+  void SetPlaybackSettings(cpb::spotify::Bitrate bitrate,
                            bool volume_normalisation);
   void LoadToplist();
   void SetPaused(const bool paused);
@@ -69,43 +69,43 @@
 
  signals:
   void LoginCompleted(bool success, const QString& error,
-                      pb::spotify::LoginResponse_Error error_code);
-  void PlaylistsUpdated(const pb::spotify::Playlists& playlists);
+                      cpb::spotify::LoginResponse_Error error_code);
+  void PlaylistsUpdated(const cpb::spotify::Playlists& playlists);
 
-  void StarredLoaded(const pb::spotify::LoadPlaylistResponse& response);
-  void InboxLoaded(const pb::spotify::LoadPlaylistResponse& response);
-  void UserPlaylistLoaded(const pb::spotify::LoadPlaylistResponse& response);
+  void StarredLoaded(const cpb::spotify::LoadPlaylistResponse& response);
+  void InboxLoaded(const cpb::spotify::LoadPlaylistResponse& response);
+  void UserPlaylistLoaded(const cpb::spotify::LoadPlaylistResponse& response);
   void PlaybackError(const QString& message);
-  void SearchResults(const pb::spotify::SearchResponse& response);
+  void SearchResults(const cpb::spotify::SearchResponse& response);
   void ImageLoaded(const QString& id, const QImage& image);
-  void SyncPlaylistProgress(const pb::spotify::SyncPlaylistProgress& progress);
-  void AlbumBrowseResults(const pb::spotify::BrowseAlbumResponse& response);
-  void ToplistBrowseResults(const pb::spotify::BrowseToplistResponse& response);
+  void SyncPlaylistProgress(const cpb::spotify::SyncPlaylistProgress& progress);
+  void AlbumBrowseResults(const cpb::spotify::BrowseAlbumResponse& response);
+  void ToplistBrowseResults(const cpb::spotify::BrowseToplistResponse& response);
 
  protected:
-  void MessageArrived(const pb::spotify::Message& message);
+  void MessageArrived(const cpb::spotify::Message& message);
 
  private slots:
   void NewConnection();
 
  private:
-  void LoadPlaylist(pb::spotify::PlaylistType type, int index = -1);
-  void SyncPlaylist(pb::spotify::PlaylistType type, int index, bool offline);
-  void AddSongsToPlaylist(const pb::spotify::PlaylistType playlist_type,
+  void LoadPlaylist(cpb::spotify::PlaylistType type, int index = -1);
+  void SyncPlaylist(cpb::spotify::PlaylistType type, int index, bool offline);
+  void AddSongsToPlaylist(const cpb::spotify::PlaylistType playlist_type,
                           const QList<QUrl>& songs_urls,
                           // Used iff type is user_playlist
                           int playlist_index = -1);
-  void RemoveSongsFromPlaylist(const pb::spotify::PlaylistType playlist_type,
+  void RemoveSongsFromPlaylist(const cpb::spotify::PlaylistType playlist_type,
                                const QList<int>& songs_indices_to_remove,
                                // Used iff type is user_playlist
                                int playlist_index = -1);
-  void SendOrQueueMessage(const pb::spotify::Message& message);
+  void SendOrQueueMessage(const cpb::spotify::Message& message);
 
   QTcpServer* server_;
   bool logged_in_;
 
-  QList<pb::spotify::Message> queued_login_messages_;
-  QList<pb::spotify::Message> queued_messages_;
+  QList<cpb::spotify::Message> queued_login_messages_;
+  QList<cpb::spotify::Message> queued_messages_;
 };
 
 #endif  // INTERNET_SPOTIFY_SPOTIFYSERVER_H_
diff -ur src/internet/spotify/spotifyservice.cpp src/internet/spotify/spotifyservice.cpp
--- a/src/internet/spotify/spotifyservice.cpp	2020-09-23 22:34:08.000000000 -0400
+++ b/src/internet/spotify/spotifyservice.cpp	2021-02-19 12:03:48.238473040 -0500
@@ -85,7 +85,7 @@
       search_box_(new SearchBoxWidget(this)),
       search_delay_(new QTimer(this)),
       login_state_(LoginState_OtherError),
-      bitrate_(pb::spotify::Bitrate320k),
+      bitrate_(cpb::spotify::Bitrate320k),
       volume_normalisation_(false) {
 // Build the search path for the binary blob.
 // Look for one distributed alongside clementine first, then check in the
@@ -174,7 +174,7 @@
 
 void SpotifyService::LoginCompleted(
     bool success, const QString& error,
-    pb::spotify::LoginResponse_Error error_code) {
+    cpb::spotify::LoginResponse_Error error_code) {
   if (login_task_id_) {
     app_->task_manager()->SetTaskFinished(login_task_id_);
     login_task_id_ = 0;
@@ -185,19 +185,19 @@
     QString error_copy(error);
 
     switch (error_code) {
-      case pb::spotify::LoginResponse_Error_BadUsernameOrPassword:
+      case cpb::spotify::LoginResponse_Error_BadUsernameOrPassword:
         login_state_ = LoginState_BadCredentials;
         break;
 
-      case pb::spotify::LoginResponse_Error_UserBanned:
+      case cpb::spotify::LoginResponse_Error_UserBanned:
         login_state_ = LoginState_Banned;
         break;
 
-      case pb::spotify::LoginResponse_Error_UserNeedsPremium:
+      case cpb::spotify::LoginResponse_Error_UserNeedsPremium:
         login_state_ = LoginState_NoPremium;
         break;
 
-      case pb::spotify::LoginResponse_Error_ReloginFailed:
+      case cpb::spotify::LoginResponse_Error_ReloginFailed:
         if (login_state_ == LoginState_LoggedIn) {
           // This is the first time the relogin has failed - show a message this
           // time only.
@@ -247,8 +247,8 @@
 
   login_state_ =
       LoginState(s.value("login_state", LoginState_OtherError).toInt());
-  bitrate_ = static_cast<pb::spotify::Bitrate>(
-      s.value("bitrate", pb::spotify::Bitrate320k).toInt());
+  bitrate_ = static_cast<cpb::spotify::Bitrate>(
+      s.value("bitrate", cpb::spotify::Bitrate320k).toInt());
   volume_normalisation_ = s.value("volume_normalisation", false).toBool();
 
   if (server_ && blob_process_) {
@@ -267,29 +267,29 @@
 
   connect(
       server_,
-      SIGNAL(LoginCompleted(bool, QString, pb::spotify::LoginResponse_Error)),
-      SLOT(LoginCompleted(bool, QString, pb::spotify::LoginResponse_Error)));
-  connect(server_, SIGNAL(PlaylistsUpdated(pb::spotify::Playlists)),
-          SLOT(PlaylistsUpdated(pb::spotify::Playlists)));
-  connect(server_, SIGNAL(InboxLoaded(pb::spotify::LoadPlaylistResponse)),
-          SLOT(InboxLoaded(pb::spotify::LoadPlaylistResponse)));
-  connect(server_, SIGNAL(StarredLoaded(pb::spotify::LoadPlaylistResponse)),
-          SLOT(StarredLoaded(pb::spotify::LoadPlaylistResponse)));
+      SIGNAL(LoginCompleted(bool, QString, cpb::spotify::LoginResponse_Error)),
+      SLOT(LoginCompleted(bool, QString, cpb::spotify::LoginResponse_Error)));
+  connect(server_, SIGNAL(PlaylistsUpdated(cpb::spotify::Playlists)),
+          SLOT(PlaylistsUpdated(cpb::spotify::Playlists)));
+  connect(server_, SIGNAL(InboxLoaded(cpb::spotify::LoadPlaylistResponse)),
+          SLOT(InboxLoaded(cpb::spotify::LoadPlaylistResponse)));
+  connect(server_, SIGNAL(StarredLoaded(cpb::spotify::LoadPlaylistResponse)),
+          SLOT(StarredLoaded(cpb::spotify::LoadPlaylistResponse)));
   connect(server_,
-          SIGNAL(UserPlaylistLoaded(pb::spotify::LoadPlaylistResponse)),
-          SLOT(UserPlaylistLoaded(pb::spotify::LoadPlaylistResponse)));
+          SIGNAL(UserPlaylistLoaded(cpb::spotify::LoadPlaylistResponse)),
+          SLOT(UserPlaylistLoaded(cpb::spotify::LoadPlaylistResponse)));
   connect(server_, SIGNAL(PlaybackError(QString)),
           SIGNAL(StreamError(QString)));
-  connect(server_, SIGNAL(SearchResults(pb::spotify::SearchResponse)),
-          SLOT(SearchResults(pb::spotify::SearchResponse)));
+  connect(server_, SIGNAL(SearchResults(cpb::spotify::SearchResponse)),
+          SLOT(SearchResults(cpb::spotify::SearchResponse)));
   connect(server_, SIGNAL(ImageLoaded(QString, QImage)),
           SIGNAL(ImageLoaded(QString, QImage)));
   connect(server_,
-          SIGNAL(SyncPlaylistProgress(pb::spotify::SyncPlaylistProgress)),
-          SLOT(SyncPlaylistProgress(pb::spotify::SyncPlaylistProgress)));
+          SIGNAL(SyncPlaylistProgress(cpb::spotify::SyncPlaylistProgress)),
+          SLOT(SyncPlaylistProgress(cpb::spotify::SyncPlaylistProgress)));
   connect(server_,
-          SIGNAL(ToplistBrowseResults(pb::spotify::BrowseToplistResponse)),
-          SLOT(ToplistLoaded(pb::spotify::BrowseToplistResponse)));
+          SIGNAL(ToplistBrowseResults(cpb::spotify::BrowseToplistResponse)),
+          SLOT(ToplistLoaded(cpb::spotify::BrowseToplistResponse)));
 
   server_->Init();
 
@@ -432,7 +432,7 @@
   root_->appendRow(inbox_);
 }
 
-void SpotifyService::PlaylistsUpdated(const pb::spotify::Playlists& response) {
+void SpotifyService::PlaylistsUpdated(const cpb::spotify::Playlists& response) {
   if (login_task_id_) {
     app_->task_manager()->SetTaskFinished(login_task_id_);
     login_task_id_ = 0;
@@ -463,7 +463,7 @@
   playlists_.clear();
 
   for (int i = 0; i < response.playlist_size(); ++i) {
-    const pb::spotify::Playlists::Playlist& msg = response.playlist(i);
+    const cpb::spotify::Playlists::Playlist& msg = response.playlist(i);
 
     QString playlist_title = QStringFromStdString(msg.name());
     if (!msg.is_mine()) {
@@ -490,13 +490,13 @@
 }
 
 bool SpotifyService::DoPlaylistsDiffer(
-    const pb::spotify::Playlists& response) const {
+    const cpb::spotify::Playlists& response) const {
   if (playlists_.count() != response.playlist_size()) {
     return true;
   }
 
   for (int i = 0; i < response.playlist_size(); ++i) {
-    const pb::spotify::Playlists::Playlist& msg = response.playlist(i);
+    const cpb::spotify::Playlists::Playlist& msg = response.playlist(i);
     const QStandardItem* item = PlaylistBySpotifyIndex(msg.index());
 
     if (!item) {
@@ -516,21 +516,21 @@
 }
 
 void SpotifyService::InboxLoaded(
-    const pb::spotify::LoadPlaylistResponse& response) {
+    const cpb::spotify::LoadPlaylistResponse& response) {
   if (inbox_) {
     FillPlaylist(inbox_, response);
   }
 }
 
 void SpotifyService::StarredLoaded(
-    const pb::spotify::LoadPlaylistResponse& response) {
+    const cpb::spotify::LoadPlaylistResponse& response) {
   if (starred_) {
     FillPlaylist(starred_, response);
   }
 }
 
 void SpotifyService::ToplistLoaded(
-    const pb::spotify::BrowseToplistResponse& response) {
+    const cpb::spotify::BrowseToplistResponse& response) {
   if (toplist_) {
     FillPlaylist(toplist_, response.track());
   }
@@ -546,7 +546,7 @@
 }
 
 void SpotifyService::UserPlaylistLoaded(
-    const pb::spotify::LoadPlaylistResponse& response) {
+    const cpb::spotify::LoadPlaylistResponse& response) {
   // Find a playlist with this index
   QStandardItem* item =
       PlaylistBySpotifyIndex(response.request().user_playlist_index());
@@ -557,7 +557,7 @@
 
 void SpotifyService::FillPlaylist(
     QStandardItem* item,
-    const google::protobuf::RepeatedPtrField<pb::spotify::Track>& tracks) {
+    const google::protobuf::RepeatedPtrField<cpb::spotify::Track>& tracks) {
   if (item->hasChildren()) item->removeRows(0, item->rowCount());
 
   for (int i = 0; i < tracks.size(); ++i) {
@@ -571,12 +571,12 @@
 }
 
 void SpotifyService::FillPlaylist(
-    QStandardItem* item, const pb::spotify::LoadPlaylistResponse& response) {
+    QStandardItem* item, const cpb::spotify::LoadPlaylistResponse& response) {
   qLog(Debug) << "Filling playlist:" << item->text();
   FillPlaylist(item, response.track());
 }
 
-void SpotifyService::SongFromProtobuf(const pb::spotify::Track& track,
+void SpotifyService::SongFromProtobuf(const cpb::spotify::Track& track,
                                       Song* song) {
   song->set_rating(track.starred() ? 1.0 : 0.0);
   song->set_title(QStringFromStdString(track.title()));
@@ -747,7 +747,7 @@
 }
 
 void SpotifyService::SearchResults(
-    const pb::spotify::SearchResponse& response) {
+    const cpb::spotify::SearchResponse& response) {
   if (QStringFromStdString(response.request().query()) != pending_search_) {
     qLog(Debug) << "Old search result for"
                 << QStringFromStdString(response.request().query())
@@ -888,17 +888,17 @@
 }
 
 void SpotifyService::SyncPlaylistProgress(
-    const pb::spotify::SyncPlaylistProgress& progress) {
+    const cpb::spotify::SyncPlaylistProgress& progress) {
   qLog(Debug) << "Sync progress:" << progress.sync_progress();
   int task_id = -1;
   switch (progress.request().type()) {
-    case pb::spotify::Inbox:
+    case cpb::spotify::Inbox:
       task_id = inbox_sync_id_;
       break;
-    case pb::spotify::Starred:
+    case cpb::spotify::Starred:
       task_id = starred_sync_id_;
       break;
-    case pb::spotify::UserPlaylist: {
+    case cpb::spotify::UserPlaylist: {
       QMap<int, int>::const_iterator it = playlist_sync_ids_.constFind(
           progress.request().user_playlist_index());
       if (it != playlist_sync_ids_.constEnd()) {
@@ -916,7 +916,7 @@
   app_->task_manager()->SetTaskProgress(task_id, progress.sync_progress(), 100);
   if (progress.sync_progress() == 100) {
     app_->task_manager()->SetTaskFinished(task_id);
-    if (progress.request().type() == pb::spotify::UserPlaylist) {
+    if (progress.request().type() == cpb::spotify::UserPlaylist) {
       playlist_sync_ids_.remove(task_id);
     }
   }
diff -ur src/internet/spotify/spotifyservice.h src/internet/spotify/spotifyservice.h
--- a/src/internet/spotify/spotifyservice.h	2020-09-23 22:34:08.000000000 -0400
+++ b/src/internet/spotify/spotifyservice.h	2021-02-19 12:03:48.238473040 -0500
@@ -93,7 +93,7 @@
   LoginState login_state() const { return login_state_; }
   bool IsLoggedIn() const { return login_state_ == LoginState_LoggedIn; }
 
-  static void SongFromProtobuf(const pb::spotify::Track& track, Song* song);
+  static void SongFromProtobuf(const cpb::spotify::Track& track, Song* song);
 
  signals:
   void BlobStateChanged();
@@ -109,9 +109,9 @@
   void StartBlobProcess();
   void FillPlaylist(
       QStandardItem* item,
-      const google::protobuf::RepeatedPtrField<pb::spotify::Track>& tracks);
+      const google::protobuf::RepeatedPtrField<cpb::spotify::Track>& tracks);
   void FillPlaylist(QStandardItem* item,
-                    const pb::spotify::LoadPlaylistResponse& response);
+                    const cpb::spotify::LoadPlaylistResponse& response);
   void AddSongsToUserPlaylist(int playlist_index,
                               const QList<QUrl>& songs_urls);
   void AddSongsToStarred(const QList<QUrl>& songs_urls);
@@ -123,26 +123,26 @@
   void InitSearch();
   void ClearSearchResults();
   QStandardItem* PlaylistBySpotifyIndex(int index) const;
-  bool DoPlaylistsDiffer(const pb::spotify::Playlists& response) const;
+  bool DoPlaylistsDiffer(const cpb::spotify::Playlists& response) const;
 
  private slots:
   void EnsureServerCreated(const QString& username = QString(),
                            const QString& password = QString());
   void BlobProcessError(QProcess::ProcessError error);
   void LoginCompleted(bool success, const QString& error,
-                      pb::spotify::LoginResponse_Error error_code);
+                      cpb::spotify::LoginResponse_Error error_code);
   void AddCurrentSongToUserPlaylist(QAction* action);
   void AddCurrentSongToStarredPlaylist();
   void RemoveSongsFromUserPlaylist(int playlist_index,
                                    const QList<int>& songs_indices_to_remove);
   void RemoveSongsFromStarred(const QList<int>& songs_indices_to_remove);
-  void PlaylistsUpdated(const pb::spotify::Playlists& response);
-  void InboxLoaded(const pb::spotify::LoadPlaylistResponse& response);
-  void StarredLoaded(const pb::spotify::LoadPlaylistResponse& response);
-  void UserPlaylistLoaded(const pb::spotify::LoadPlaylistResponse& response);
-  void SearchResults(const pb::spotify::SearchResponse& response);
-  void SyncPlaylistProgress(const pb::spotify::SyncPlaylistProgress& progress);
-  void ToplistLoaded(const pb::spotify::BrowseToplistResponse& response);
+  void PlaylistsUpdated(const cpb::spotify::Playlists& response);
+  void InboxLoaded(const cpb::spotify::LoadPlaylistResponse& response);
+  void StarredLoaded(const cpb::spotify::LoadPlaylistResponse& response);
+  void UserPlaylistLoaded(const cpb::spotify::LoadPlaylistResponse& response);
+  void SearchResults(const cpb::spotify::SearchResponse& response);
+  void SyncPlaylistProgress(const cpb::spotify::SyncPlaylistProgress& progress);
+  void ToplistLoaded(const cpb::spotify::BrowseToplistResponse& response);
   void GetCurrentSongUrlToShare() const;
   void GetCurrentPlaylistUrlToShare() const;
 
@@ -188,7 +188,7 @@
   QMap<int, int> playlist_sync_ids_;
 
   LoginState login_state_;
-  pb::spotify::Bitrate bitrate_;
+  cpb::spotify::Bitrate bitrate_;
   bool volume_normalisation_;
 };
 
diff -ur src/internet/spotify/spotifysettingspage.cpp src/internet/spotify/spotifysettingspage.cpp
--- a/src/internet/spotify/spotifysettingspage.cpp	2020-09-23 22:34:08.000000000 -0400
+++ b/src/internet/spotify/spotifysettingspage.cpp	2021-02-19 12:03:48.238473040 -0500
@@ -59,9 +59,9 @@
   ui_->login_state->AddCredentialField(ui_->password);
   ui_->login_state->AddCredentialGroup(ui_->account_group);
 
-  ui_->bitrate->addItem("96 " + tr("kbps"), pb::spotify::Bitrate96k);
-  ui_->bitrate->addItem("160 " + tr("kbps"), pb::spotify::Bitrate160k);
-  ui_->bitrate->addItem("320 " + tr("kbps"), pb::spotify::Bitrate320k);
+  ui_->bitrate->addItem("96 " + tr("kbps"), cpb::spotify::Bitrate96k);
+  ui_->bitrate->addItem("160 " + tr("kbps"), cpb::spotify::Bitrate160k);
+  ui_->bitrate->addItem("320 " + tr("kbps"), cpb::spotify::Bitrate320k);
 
   BlobStateChanged();
 }
@@ -108,7 +108,7 @@
   validated_ = false;
 
   ui_->bitrate->setCurrentIndex(ui_->bitrate->findData(
-      s.value("bitrate", pb::spotify::Bitrate320k).toInt()));
+      s.value("bitrate", cpb::spotify::Bitrate320k).toInt()));
   ui_->volume_normalisation->setChecked(
       s.value("volume_normalisation", false).toBool());
 
diff -ur src/main.cpp src/main.cpp
--- a/src/main.cpp	2020-09-23 22:34:08.000000000 -0400
+++ b/src/main.cpp	2021-02-19 12:03:48.238473040 -0500
@@ -191,7 +191,7 @@
       "304c6f756e67652e6d786dba012a28414c42554d2920476f74616e2050726f6a65637"
       "4202d20416d6269656e74204c6f756e67652e6d786dc001c7a7efd104c801bad685e4"
       "04d001eeca32");
-  pb::tagreader::Message message;
+  cpb::tagreader::Message message;
   message.ParseFromArray(data.constData(), data.size());
 }
 
diff -ur src/networkremote/incomingdataparser.cpp src/networkremote/incomingdataparser.cpp
--- a/src/networkremote/incomingdataparser.cpp	2020-09-23 22:34:08.000000000 -0400
+++ b/src/networkremote/incomingdataparser.cpp	2021-02-19 12:03:48.239473043 -0500
@@ -97,99 +97,99 @@
 
 bool IncomingDataParser::close_connection() { return close_connection_; }
 
-void IncomingDataParser::Parse(const pb::remote::Message& msg) {
+void IncomingDataParser::Parse(const cpb::remote::Message& msg) {
   close_connection_ = false;
 
   RemoteClient* client = qobject_cast<RemoteClient*>(sender());
 
   // Now check what's to do
   switch (msg.type()) {
-    case pb::remote::CONNECT:
+    case cpb::remote::CONNECT:
       ClientConnect(msg, client);
       break;
-    case pb::remote::DISCONNECT:
+    case cpb::remote::DISCONNECT:
       close_connection_ = true;
       break;
-    case pb::remote::REQUEST_PLAYLISTS:
+    case cpb::remote::REQUEST_PLAYLISTS:
       SendPlaylists(msg);
       break;
-    case pb::remote::REQUEST_PLAYLIST_SONGS:
+    case cpb::remote::REQUEST_PLAYLIST_SONGS:
       GetPlaylistSongs(msg);
       break;
-    case pb::remote::SET_VOLUME:
+    case cpb::remote::SET_VOLUME:
       emit SetVolume(msg.request_set_volume().volume());
       break;
-    case pb::remote::PLAY:
+    case cpb::remote::PLAY:
       emit Play();
       break;
-    case pb::remote::PLAYPAUSE:
+    case cpb::remote::PLAYPAUSE:
       emit PlayPause();
       break;
-    case pb::remote::PAUSE:
+    case cpb::remote::PAUSE:
       emit Pause();
       break;
-    case pb::remote::STOP:
+    case cpb::remote::STOP:
       emit Stop();
       break;
-    case pb::remote::STOP_AFTER:
+    case cpb::remote::STOP_AFTER:
       emit StopAfterCurrent();
       break;
-    case pb::remote::NEXT:
+    case cpb::remote::NEXT:
       emit Next();
       break;
-    case pb::remote::PREVIOUS:
+    case cpb::remote::PREVIOUS:
       emit Previous();
       break;
-    case pb::remote::CHANGE_SONG:
+    case cpb::remote::CHANGE_SONG:
       ChangeSong(msg);
       break;
-    case pb::remote::SHUFFLE_PLAYLIST:
+    case cpb::remote::SHUFFLE_PLAYLIST:
       emit ShuffleCurrent();
       break;
-    case pb::remote::REPEAT:
+    case cpb::remote::REPEAT:
       SetRepeatMode(msg.repeat());
       break;
-    case pb::remote::SHUFFLE:
+    case cpb::remote::SHUFFLE:
       SetShuffleMode(msg.shuffle());
       break;
-    case pb::remote::SET_TRACK_POSITION:
+    case cpb::remote::SET_TRACK_POSITION:
       emit SeekTo(msg.request_set_track_position().position());
       break;
-    case pb::remote::INSERT_URLS:
+    case cpb::remote::INSERT_URLS:
       InsertUrls(msg);
       break;
-    case pb::remote::REMOVE_SONGS:
+    case cpb::remote::REMOVE_SONGS:
       RemoveSongs(msg);
       break;
-    case pb::remote::OPEN_PLAYLIST:
+    case cpb::remote::OPEN_PLAYLIST:
       OpenPlaylist(msg);
       break;
-    case pb::remote::CLOSE_PLAYLIST:
+    case cpb::remote::CLOSE_PLAYLIST:
       ClosePlaylist(msg);
       break;
-    case pb::remote::LOVE:
+    case cpb::remote::LOVE:
       emit Love();
       break;
-    case pb::remote::BAN:
+    case cpb::remote::BAN:
       emit Ban();
       break;
-    case pb::remote::GET_LYRICS:
+    case cpb::remote::GET_LYRICS:
       emit GetLyrics();
       break;
-    case pb::remote::DOWNLOAD_SONGS:
+    case cpb::remote::DOWNLOAD_SONGS:
       client->song_sender()->SendSongs(msg.request_download_songs());
       break;
-    case pb::remote::SONG_OFFER_RESPONSE:
+    case cpb::remote::SONG_OFFER_RESPONSE:
       client->song_sender()->ResponseSongOffer(
           msg.response_song_offer().accepted());
       break;
-    case pb::remote::GET_LIBRARY:
+    case cpb::remote::GET_LIBRARY:
       emit SendLibrary(client);
       break;
-    case pb::remote::RATE_SONG:
+    case cpb::remote::RATE_SONG:
       RateSong(msg);
       break;
-    case pb::remote::GLOBAL_SEARCH:
+    case cpb::remote::GLOBAL_SEARCH:
       GlobalSearch(client, msg);
       break;
     default:
@@ -197,13 +197,13 @@
   }
 }
 
-void IncomingDataParser::GetPlaylistSongs(const pb::remote::Message& msg) {
+void IncomingDataParser::GetPlaylistSongs(const cpb::remote::Message& msg) {
   emit SendPlaylistSongs(msg.request_playlist_songs().id());
 }
 
-void IncomingDataParser::ChangeSong(const pb::remote::Message& msg) {
+void IncomingDataParser::ChangeSong(const cpb::remote::Message& msg) {
   // Get the first entry and check if there is a song
-  const pb::remote::RequestChangeSong& request = msg.request_change_song();
+  const cpb::remote::RequestChangeSong& request = msg.request_change_song();
 
   // Check if we need to change the playlist
   if (request.playlist_id() != app_->playlist_manager()->active_id()) {
@@ -227,18 +227,18 @@
   }
 }
 
-void IncomingDataParser::SetRepeatMode(const pb::remote::Repeat& repeat) {
+void IncomingDataParser::SetRepeatMode(const cpb::remote::Repeat& repeat) {
   switch (repeat.repeat_mode()) {
-    case pb::remote::Repeat_Off:
+    case cpb::remote::Repeat_Off:
       emit SetRepeatMode(PlaylistSequence::Repeat_Off);
       break;
-    case pb::remote::Repeat_Track:
+    case cpb::remote::Repeat_Track:
       emit SetRepeatMode(PlaylistSequence::Repeat_Track);
       break;
-    case pb::remote::Repeat_Album:
+    case cpb::remote::Repeat_Album:
       emit SetRepeatMode(PlaylistSequence::Repeat_Album);
       break;
-    case pb::remote::Repeat_Playlist:
+    case cpb::remote::Repeat_Playlist:
       emit SetRepeatMode(PlaylistSequence::Repeat_Playlist);
       break;
     default:
@@ -246,18 +246,18 @@
   }
 }
 
-void IncomingDataParser::SetShuffleMode(const pb::remote::Shuffle& shuffle) {
+void IncomingDataParser::SetShuffleMode(const cpb::remote::Shuffle& shuffle) {
   switch (shuffle.shuffle_mode()) {
-    case pb::remote::Shuffle_Off:
+    case cpb::remote::Shuffle_Off:
       emit SetShuffleMode(PlaylistSequence::Shuffle_Off);
       break;
-    case pb::remote::Shuffle_All:
+    case cpb::remote::Shuffle_All:
       emit SetShuffleMode(PlaylistSequence::Shuffle_All);
       break;
-    case pb::remote::Shuffle_InsideAlbum:
+    case cpb::remote::Shuffle_InsideAlbum:
       emit SetShuffleMode(PlaylistSequence::Shuffle_InsideAlbum);
       break;
-    case pb::remote::Shuffle_Albums:
+    case cpb::remote::Shuffle_Albums:
       emit SetShuffleMode(PlaylistSequence::Shuffle_Albums);
       break;
     default:
@@ -265,8 +265,8 @@
   }
 }
 
-void IncomingDataParser::InsertUrls(const pb::remote::Message& msg) {
-  const pb::remote::RequestInsertUrls& request = msg.request_insert_urls();
+void IncomingDataParser::InsertUrls(const cpb::remote::Message& msg) {
+  const cpb::remote::RequestInsertUrls& request = msg.request_insert_urls();
 
   // Insert plain urls without metadata
   if (!request.urls().empty()) {
@@ -292,8 +292,8 @@
   }
 }
 
-void IncomingDataParser::RemoveSongs(const pb::remote::Message& msg) {
-  const pb::remote::RequestRemoveSongs& request = msg.request_remove_songs();
+void IncomingDataParser::RemoveSongs(const cpb::remote::Message& msg) {
+  const cpb::remote::RequestRemoveSongs& request = msg.request_remove_songs();
 
   // Extract urls
   QList<int> songs;
@@ -305,7 +305,7 @@
   emit RemoveSongs(request.playlist_id(), songs);
 }
 
-void IncomingDataParser::ClientConnect(const pb::remote::Message& msg,
+void IncomingDataParser::ClientConnect(const cpb::remote::Message& msg,
                                        RemoteClient* client) {
   // Always sned the Clementine infos
   emit SendClementineInfo();
@@ -321,7 +321,7 @@
   }
 }
 
-void IncomingDataParser::SendPlaylists(const pb::remote::Message& msg) {
+void IncomingDataParser::SendPlaylists(const cpb::remote::Message& msg) {
   if (!msg.has_request_playlists() ||
       !msg.request_playlists().include_closed()) {
     emit SendAllActivePlaylists();
@@ -330,27 +330,27 @@
   }
 }
 
-void IncomingDataParser::OpenPlaylist(const pb::remote::Message& msg) {
+void IncomingDataParser::OpenPlaylist(const cpb::remote::Message& msg) {
   emit Open(msg.request_open_playlist().playlist_id());
 }
 
-void IncomingDataParser::ClosePlaylist(const pb::remote::Message& msg) {
+void IncomingDataParser::ClosePlaylist(const cpb::remote::Message& msg) {
   emit Close(msg.request_close_playlist().playlist_id());
 }
 
-void IncomingDataParser::RateSong(const pb::remote::Message& msg) {
+void IncomingDataParser::RateSong(const cpb::remote::Message& msg) {
   double rating = (double)msg.request_rate_song().rating();
   emit RateCurrentSong(rating);
 }
 
 void IncomingDataParser::GlobalSearch(RemoteClient* client,
-                                      const pb::remote::Message& msg) {
+                                      const cpb::remote::Message& msg) {
   emit DoGlobalSearch(QStringFromStdString(msg.request_global_search().query()),
                       client);
 }
 
 Song IncomingDataParser::CreateSongFromProtobuf(
-    const pb::remote::SongMetadata& pb) {
+    const cpb::remote::SongMetadata& pb) {
   Song song;
   song.Init(QStringFromStdString(pb.title()), QStringFromStdString(pb.artist()),
             QStringFromStdString(pb.album()), pb.length() * kNsecPerSec);
diff -ur src/networkremote/incomingdataparser.h src/networkremote/incomingdataparser.h
--- a/src/networkremote/incomingdataparser.h	2020-09-23 22:34:08.000000000 -0400
+++ b/src/networkremote/incomingdataparser.h	2021-02-19 12:03:48.239473043 -0500
@@ -16,7 +16,7 @@
   bool close_connection();
 
  public slots:
-  void Parse(const pb::remote::Message& msg);
+  void Parse(const cpb::remote::Message& msg);
   void ReloadSettings();
 
  signals:
@@ -61,20 +61,20 @@
   bool close_connection_;
   MainWindow::PlaylistAddBehaviour doubleclick_playlist_addmode_;
 
-  void GetPlaylistSongs(const pb::remote::Message& msg);
-  void ChangeSong(const pb::remote::Message& msg);
-  void SetRepeatMode(const pb::remote::Repeat& repeat);
-  void SetShuffleMode(const pb::remote::Shuffle& shuffle);
-  void InsertUrls(const pb::remote::Message& msg);
-  void RemoveSongs(const pb::remote::Message& msg);
-  void ClientConnect(const pb::remote::Message& msg, RemoteClient* client);
-  void SendPlaylists(const pb::remote::Message& msg);
-  void OpenPlaylist(const pb::remote::Message& msg);
-  void ClosePlaylist(const pb::remote::Message& msg);
-  void RateSong(const pb::remote::Message& msg);
-  void GlobalSearch(RemoteClient* client, const pb::remote::Message& msg);
+  void GetPlaylistSongs(const cpb::remote::Message& msg);
+  void ChangeSong(const cpb::remote::Message& msg);
+  void SetRepeatMode(const cpb::remote::Repeat& repeat);
+  void SetShuffleMode(const cpb::remote::Shuffle& shuffle);
+  void InsertUrls(const cpb::remote::Message& msg);
+  void RemoveSongs(const cpb::remote::Message& msg);
+  void ClientConnect(const cpb::remote::Message& msg, RemoteClient* client);
+  void SendPlaylists(const cpb::remote::Message& msg);
+  void OpenPlaylist(const cpb::remote::Message& msg);
+  void ClosePlaylist(const cpb::remote::Message& msg);
+  void RateSong(const cpb::remote::Message& msg);
+  void GlobalSearch(RemoteClient* client, const cpb::remote::Message& msg);
 
-  Song CreateSongFromProtobuf(const pb::remote::SongMetadata& pb);
+  Song CreateSongFromProtobuf(const cpb::remote::SongMetadata& pb);
 };
 
 #endif  // INCOMINGDATAPARSER_H
diff -ur src/networkremote/networkremote.cpp src/networkremote/networkremote.cpp
--- a/src/networkremote/networkremote.cpp	2020-09-23 22:34:08.000000000 -0400
+++ b/src/networkremote/networkremote.cpp	2021-02-19 12:03:48.239473043 -0500
@@ -214,8 +214,8 @@
     clients_.push_back(client);
 
     // Connect the signal to parse data
-    connect(client, SIGNAL(Parse(pb::remote::Message)),
-            incoming_data_parser_.get(), SLOT(Parse(pb::remote::Message)));
+    connect(client, SIGNAL(Parse(cpb::remote::Message)),
+            incoming_data_parser_.get(), SLOT(Parse(cpb::remote::Message)));
   }
 }
 
diff -ur src/networkremote/outgoingdatacreator.cpp src/networkremote/outgoingdatacreator.cpp
--- a/src/networkremote/outgoingdatacreator.cpp	2020-09-23 22:34:08.000000000 -0400
+++ b/src/networkremote/outgoingdatacreator.cpp	2021-02-19 12:03:48.239473043 -0500
@@ -144,7 +144,7 @@
   return nullptr;
 }
 
-void OutgoingDataCreator::SendDataToClients(pb::remote::Message* msg) {
+void OutgoingDataCreator::SendDataToClients(cpb::remote::Message* msg) {
   // Check if we have clients to send data to
   if (clients_->empty()) {
     return;
@@ -172,11 +172,11 @@
 
 void OutgoingDataCreator::SendClementineInfo() {
   // Create the general message and set the message type
-  pb::remote::Message msg;
-  msg.set_type(pb::remote::INFO);
+  cpb::remote::Message msg;
+  msg.set_type(cpb::remote::INFO);
 
   // Now add the message specific data
-  pb::remote::ResponseClementineInfo* info =
+  cpb::remote::ResponseClementineInfo* info =
       msg.mutable_response_clementine_info();
   SetEngineState(info);
 
@@ -188,20 +188,20 @@
 }
 
 void OutgoingDataCreator::SetEngineState(
-    pb::remote::ResponseClementineInfo* msg) {
+    cpb::remote::ResponseClementineInfo* msg) {
   switch (app_->player()->GetState()) {
     case Engine::Idle:
-      msg->set_state(pb::remote::Idle);
+      msg->set_state(cpb::remote::Idle);
       break;
     case Engine::Error:
     case Engine::Empty:
-      msg->set_state(pb::remote::Empty);
+      msg->set_state(cpb::remote::Empty);
       break;
     case Engine::Playing:
-      msg->set_state(pb::remote::Playing);
+      msg->set_state(cpb::remote::Playing);
       break;
     case Engine::Paused:
-      msg->set_state(pb::remote::Paused);
+      msg->set_state(cpb::remote::Paused);
       break;
   }
 }
@@ -212,10 +212,10 @@
   int active_playlist = app_->playlist_manager()->active_id();
 
   // Create message
-  pb::remote::Message msg;
-  msg.set_type(pb::remote::PLAYLISTS);
+  cpb::remote::Message msg;
+  msg.set_type(cpb::remote::PLAYLISTS);
 
-  pb::remote::ResponsePlaylists* playlists = msg.mutable_response_playlists();
+  cpb::remote::ResponsePlaylists* playlists = msg.mutable_response_playlists();
 
   // Get all playlists, even ones that are hidden in the UI.
   for (const PlaylistBackend::Playlist& p :
@@ -224,7 +224,7 @@
     int item_count = playlist_open ? app_playlists.at(p.id)->rowCount() : 0;
 
     // Create a new playlist
-    pb::remote::Playlist* playlist = playlists->add_playlist();
+    cpb::remote::Playlist* playlist = playlists->add_playlist();
     playlist->set_name(DataCommaSizeFromQString(p.name));
     playlist->set_id(p.id);
     playlist->set_active((p.id == active_playlist));
@@ -241,10 +241,10 @@
   int active_playlist = app_->playlist_manager()->active_id();
 
   // Create message
-  pb::remote::Message msg;
-  msg.set_type(pb::remote::PLAYLISTS);
+  cpb::remote::Message msg;
+  msg.set_type(cpb::remote::PLAYLISTS);
 
-  pb::remote::ResponsePlaylists* playlists = msg.mutable_response_playlists();
+  cpb::remote::ResponsePlaylists* playlists = msg.mutable_response_playlists();
 
   QListIterator<Playlist*> it(app_playlists);
   while (it.hasNext()) {
@@ -253,7 +253,7 @@
     QString playlist_name = app_->playlist_manager()->GetPlaylistName(p->id());
 
     // Create a new playlist
-    pb::remote::Playlist* playlist = playlists->add_playlist();
+    cpb::remote::Playlist* playlist = playlists->add_playlist();
     playlist->set_name(DataCommaSizeFromQString(playlist_name));
     playlist->set_id(p->id());
     playlist->set_active((p->id() == active_playlist));
@@ -269,8 +269,8 @@
   SendPlaylistSongs(playlist->id());
 
   // Send the changed message after sending the playlist songs
-  pb::remote::Message msg;
-  msg.set_type(pb::remote::ACTIVE_PLAYLIST_CHANGED);
+  cpb::remote::Message msg;
+  msg.set_type(cpb::remote::ACTIVE_PLAYLIST_CHANGED);
   msg.mutable_response_active_changed()->set_id(playlist->id());
   SendDataToClients(&msg);
 }
@@ -322,8 +322,8 @@
   SendRepeatMode(app_->playlist_manager()->sequence()->repeat_mode());
 
   // We send all first data
-  pb::remote::Message msg;
-  msg.set_type(pb::remote::FIRST_DATA_SENT_COMPLETE);
+  cpb::remote::Message msg;
+  msg.set_type(cpb::remote::FIRST_DATA_SENT_COMPLETE);
   SendDataToClients(&msg);
 }
 
@@ -342,8 +342,8 @@
 
 void OutgoingDataCreator::SendSongMetadata() {
   // Create the message
-  pb::remote::Message msg;
-  msg.set_type(pb::remote::CURRENT_METAINFO);
+  cpb::remote::Message msg;
+  msg.set_type(cpb::remote::CURRENT_METAINFO);
 
   // If there is no song, create an empty node, otherwise fill it with data
   int i = app_->playlist_manager()->active()->current_row();
@@ -355,7 +355,7 @@
 
 void OutgoingDataCreator::CreateSong(const Song& song, const QImage& art,
                                      const int index,
-                                     pb::remote::SongMetadata* song_metadata) {
+                                     cpb::remote::SongMetadata* song_metadata) {
   if (song.is_valid()) {
     song_metadata->set_id(song.id());
     song_metadata->set_index(index);
@@ -381,7 +381,7 @@
         DataCommaSizeFromQString(song.art_automatic()));
     song_metadata->set_art_manual(DataCommaSizeFromQString(song.art_manual()));
     song_metadata->set_type(
-        static_cast<::pb::remote::SongMetadata_Type>(song.filetype()));
+        static_cast<::cpb::remote::SongMetadata_Type>(song.filetype()));
 
     // Append coverart
     if (!art.isNull()) {
@@ -407,8 +407,8 @@
 
 void OutgoingDataCreator::VolumeChanged(int volume) {
   // Create the message
-  pb::remote::Message msg;
-  msg.set_type(pb::remote::SET_VOLUME);
+  cpb::remote::Message msg;
+  msg.set_type(cpb::remote::SET_VOLUME);
   msg.mutable_request_set_volume()->set_volume(volume);
   SendDataToClients(&msg);
 }
@@ -422,15 +422,15 @@
   }
 
   // Create the message and the playlist
-  pb::remote::Message msg;
-  msg.set_type(pb::remote::PLAYLIST_SONGS);
+  cpb::remote::Message msg;
+  msg.set_type(cpb::remote::PLAYLIST_SONGS);
 
   // Create the Response message
-  pb::remote::ResponsePlaylistSongs* pb_response_playlist_songs =
+  cpb::remote::ResponsePlaylistSongs* pb_response_playlist_songs =
       msg.mutable_response_playlist_songs();
 
   // Create a new playlist
-  pb::remote::Playlist* pb_playlist =
+  cpb::remote::Playlist* pb_playlist =
       pb_response_playlist_songs->mutable_requested_playlist();
   pb_playlist->set_id(id);
 
@@ -441,7 +441,7 @@
   QImage null_img;
   while (it.hasNext()) {
     Song song = it.next();
-    pb::remote::SongMetadata* pb_song = pb_response_playlist_songs->add_songs();
+    cpb::remote::SongMetadata* pb_song = pb_response_playlist_songs->add_songs();
     CreateSong(song, null_img, index, pb_song);
     ++index;
   }
@@ -462,23 +462,23 @@
   }
   last_state_ = state;
 
-  pb::remote::Message msg;
+  cpb::remote::Message msg;
 
   switch (state) {
     case Engine::Playing:
-      msg.set_type(pb::remote::PLAY);
+      msg.set_type(cpb::remote::PLAY);
       track_position_timer_->start(1000);
       break;
     case Engine::Paused:
-      msg.set_type(pb::remote::PAUSE);
+      msg.set_type(cpb::remote::PAUSE);
       track_position_timer_->stop();
       break;
     case Engine::Empty:
-      msg.set_type(pb::remote::STOP);  // Empty is called when player stopped
+      msg.set_type(cpb::remote::STOP);  // Empty is called when player stopped
       track_position_timer_->stop();
       break;
     default:
-      msg.set_type(pb::remote::STOP);
+      msg.set_type(cpb::remote::STOP);
       track_position_timer_->stop();
       break;
   };
@@ -487,27 +487,27 @@
 }
 
 void OutgoingDataCreator::SendRepeatMode(PlaylistSequence::RepeatMode mode) {
-  pb::remote::Message msg;
-  msg.set_type(pb::remote::REPEAT);
+  cpb::remote::Message msg;
+  msg.set_type(cpb::remote::REPEAT);
 
   switch (mode) {
     case PlaylistSequence::Repeat_Off:
-      msg.mutable_repeat()->set_repeat_mode(pb::remote::Repeat_Off);
+      msg.mutable_repeat()->set_repeat_mode(cpb::remote::Repeat_Off);
       break;
     case PlaylistSequence::Repeat_Track:
-      msg.mutable_repeat()->set_repeat_mode(pb::remote::Repeat_Track);
+      msg.mutable_repeat()->set_repeat_mode(cpb::remote::Repeat_Track);
       break;
     case PlaylistSequence::Repeat_Album:
-      msg.mutable_repeat()->set_repeat_mode(pb::remote::Repeat_Album);
+      msg.mutable_repeat()->set_repeat_mode(cpb::remote::Repeat_Album);
       break;
     case PlaylistSequence::Repeat_Playlist:
-      msg.mutable_repeat()->set_repeat_mode(pb::remote::Repeat_Playlist);
+      msg.mutable_repeat()->set_repeat_mode(cpb::remote::Repeat_Playlist);
       break;
     case PlaylistSequence::Repeat_OneByOne:
-      msg.mutable_repeat()->set_repeat_mode(pb::remote::Repeat_OneByOne);
+      msg.mutable_repeat()->set_repeat_mode(cpb::remote::Repeat_OneByOne);
       break;
     case PlaylistSequence::Repeat_Intro:
-      msg.mutable_repeat()->set_repeat_mode(pb::remote::Repeat_Intro);
+      msg.mutable_repeat()->set_repeat_mode(cpb::remote::Repeat_Intro);
       break;
   }
 
@@ -515,21 +515,21 @@
 }
 
 void OutgoingDataCreator::SendShuffleMode(PlaylistSequence::ShuffleMode mode) {
-  pb::remote::Message msg;
-  msg.set_type(pb::remote::SHUFFLE);
+  cpb::remote::Message msg;
+  msg.set_type(cpb::remote::SHUFFLE);
 
   switch (mode) {
     case PlaylistSequence::Shuffle_Off:
-      msg.mutable_shuffle()->set_shuffle_mode(pb::remote::Shuffle_Off);
+      msg.mutable_shuffle()->set_shuffle_mode(cpb::remote::Shuffle_Off);
       break;
     case PlaylistSequence::Shuffle_All:
-      msg.mutable_shuffle()->set_shuffle_mode(pb::remote::Shuffle_All);
+      msg.mutable_shuffle()->set_shuffle_mode(cpb::remote::Shuffle_All);
       break;
     case PlaylistSequence::Shuffle_InsideAlbum:
-      msg.mutable_shuffle()->set_shuffle_mode(pb::remote::Shuffle_InsideAlbum);
+      msg.mutable_shuffle()->set_shuffle_mode(cpb::remote::Shuffle_InsideAlbum);
       break;
     case PlaylistSequence::Shuffle_Albums:
-      msg.mutable_shuffle()->set_shuffle_mode(pb::remote::Shuffle_Albums);
+      msg.mutable_shuffle()->set_shuffle_mode(cpb::remote::Shuffle_Albums);
       break;
   }
 
@@ -537,14 +537,14 @@
 }
 
 void OutgoingDataCreator::SendKeepAlive() {
-  pb::remote::Message msg;
-  msg.set_type(pb::remote::KEEP_ALIVE);
+  cpb::remote::Message msg;
+  msg.set_type(cpb::remote::KEEP_ALIVE);
   SendDataToClients(&msg);
 }
 
 void OutgoingDataCreator::UpdateTrackPosition() {
-  pb::remote::Message msg;
-  msg.set_type(pb::remote::UPDATE_TRACK_POSITION);
+  cpb::remote::Message msg;
+  msg.set_type(cpb::remote::UPDATE_TRACK_POSITION);
 
   int position = std::floor(
       float(app_->player()->engine()->position_nanosec()) / kNsecPerSec + 0.5);
@@ -561,10 +561,10 @@
 }
 
 void OutgoingDataCreator::DisconnectAllClients() {
-  pb::remote::Message msg;
-  msg.set_type(pb::remote::DISCONNECT);
+  cpb::remote::Message msg;
+  msg.set_type(cpb::remote::DISCONNECT);
   msg.mutable_response_disconnect()->set_reason_disconnect(
-      pb::remote::Server_Shutdown);
+      cpb::remote::Server_Shutdown);
   SendDataToClients(&msg);
 }
 
@@ -572,9 +572,9 @@
 
 void OutgoingDataCreator::SendLyrics(int id,
                                      const SongInfoFetcher::Result& result) {
-  pb::remote::Message msg;
-  msg.set_type(pb::remote::LYRICS);
-  pb::remote::ResponseLyrics* response = msg.mutable_response_lyrics();
+  cpb::remote::Message msg;
+  msg.set_type(cpb::remote::LYRICS);
+  cpb::remote::ResponseLyrics* response = msg.mutable_response_lyrics();
 
   for (const CollapsibleInfoPane::Data& data : result.info_) {
     // If the size is zero, do not send the provider
@@ -582,7 +582,7 @@
         qobject_cast<UltimateLyricsLyric*>(data.content_object_);
     if (editor->toPlainText().length() == 0) continue;
 
-    pb::remote::Lyric* lyric = response->mutable_lyrics()->Add();
+    cpb::remote::Lyric* lyric = response->mutable_lyrics()->Add();
 
     lyric->set_id(DataCommaSizeFromQString(data.id_));
     lyric->set_title(DataCommaSizeFromQString(data.title_));
@@ -623,10 +623,10 @@
   file.open(QIODevice::ReadOnly);
 
   QByteArray data;
-  pb::remote::Message msg;
-  pb::remote::ResponseLibraryChunk* chunk =
+  cpb::remote::Message msg;
+  cpb::remote::ResponseLibraryChunk* chunk =
       msg.mutable_response_library_chunk();
-  msg.set_type(pb::remote::LIBRARY_CHUNK);
+  msg.set_type(cpb::remote::LIBRARY_CHUNK);
 
   // Calculate the number of chunks
   int chunk_count = qRound((file.size() / kFileChunkSize) + 0.5);
@@ -674,14 +674,14 @@
   global_search_result_map_.insert(id, request);
 
   // Send status message
-  pb::remote::Message msg;
-  pb::remote::ResponseGlobalSearchStatus* status =
+  cpb::remote::Message msg;
+  cpb::remote::ResponseGlobalSearchStatus* status =
       msg.mutable_response_global_search_status();
 
-  msg.set_type(pb::remote::GLOBAL_SEARCH_STATUS);
+  msg.set_type(cpb::remote::GLOBAL_SEARCH_STATUS);
   status->set_id(id);
   status->set_query(DataCommaSizeFromQString(query));
-  status->set_status(pb::remote::GlobalSearchStarted);
+  status->set_status(cpb::remote::GlobalSearchStarted);
 
   client->SendData(&msg);
 
@@ -696,11 +696,11 @@
   RemoteClient* client = search_request.client_;
   QImage null_img;
 
-  pb::remote::Message msg;
-  pb::remote::ResponseGlobalSearch* response =
+  cpb::remote::Message msg;
+  cpb::remote::ResponseGlobalSearch* response =
       msg.mutable_response_global_search();
 
-  msg.set_type(pb::remote::GLOBAL_SEARCH_RESULT);
+  msg.set_type(cpb::remote::GLOBAL_SEARCH_RESULT);
   response->set_id(search_request.id_);
   response->set_query(DataCommaSizeFromQString(search_request.query_));
   response->set_search_provider(
@@ -715,7 +715,7 @@
   response->set_search_provider_icon(byte_array.constData(), byte_array.size());
 
   for (const SearchProvider::Result& result : results) {
-    pb::remote::SongMetadata* pb_song = response->add_song_metadata();
+    cpb::remote::SongMetadata* pb_song = response->add_song_metadata();
     CreateSong(result.metadata_, null_img, 0, pb_song);
   }
 
@@ -731,14 +731,14 @@
   GlobalSearchRequest req = global_search_result_map_.take(id);
 
   // Send status message
-  pb::remote::Message msg;
-  pb::remote::ResponseGlobalSearchStatus* status =
+  cpb::remote::Message msg;
+  cpb::remote::ResponseGlobalSearchStatus* status =
       msg.mutable_response_global_search_status();
 
-  msg.set_type(pb::remote::GLOBAL_SEARCH_STATUS);
+  msg.set_type(cpb::remote::GLOBAL_SEARCH_STATUS);
   status->set_id(req.id_);
   status->set_query(DataCommaSizeFromQString(req.query_));
-  status->set_status(pb::remote::GlobalSearchFinished);
+  status->set_status(cpb::remote::GlobalSearchFinished);
 
   req.client_->SendData(&msg);
 
diff -ur src/networkremote/outgoingdatacreator.h src/networkremote/outgoingdatacreator.h
--- a/src/networkremote/outgoingdatacreator.h	2020-09-23 22:34:08.000000000 -0400
+++ b/src/networkremote/outgoingdatacreator.h	2021-02-19 12:03:48.239473043 -0500
@@ -49,7 +49,7 @@
   void SetClients(QList<RemoteClient*>* clients);
 
   static void CreateSong(const Song& song, const QImage& art, const int index,
-                         pb::remote::SongMetadata* song_metadata);
+                         cpb::remote::SongMetadata* song_metadata);
 
  public slots:
   void SendClementineInfo();
@@ -102,8 +102,8 @@
 
   QMap<int, GlobalSearchRequest> global_search_result_map_;
 
-  void SendDataToClients(pb::remote::Message* msg);
-  void SetEngineState(pb::remote::ResponseClementineInfo* msg);
+  void SendDataToClients(cpb::remote::Message* msg);
+  void SetEngineState(cpb::remote::ResponseClementineInfo* msg);
   void CheckEnabledProviders();
   SongInfoProvider* ProviderByName(const QString& name) const;
 };
diff -ur src/networkremote/remoteclient.cpp src/networkremote/remoteclient.cpp
--- a/src/networkremote/remoteclient.cpp	2020-09-23 22:34:08.000000000 -0400
+++ b/src/networkremote/remoteclient.cpp	2021-02-19 12:03:48.240473046 -0500
@@ -103,33 +103,33 @@
 }
 
 void RemoteClient::ParseMessage(const QByteArray& data) {
-  pb::remote::Message msg;
+  cpb::remote::Message msg;
   if (!msg.ParseFromArray(data.constData(), data.size())) {
     qLog(Info) << "Couldn't parse data";
     return;
   }
 
-  if (msg.type() == pb::remote::CONNECT && use_auth_code_) {
+  if (msg.type() == cpb::remote::CONNECT && use_auth_code_) {
     if (msg.request_connect().auth_code() != auth_code_) {
-      DisconnectClient(pb::remote::Wrong_Auth_Code);
+      DisconnectClient(cpb::remote::Wrong_Auth_Code);
       return;
     } else {
       authenticated_ = true;
     }
   }
 
-  if (msg.type() == pb::remote::CONNECT) {
+  if (msg.type() == cpb::remote::CONNECT) {
     setDownloader(msg.request_connect().downloader());
     qDebug() << "Downloader" << downloader_;
   }
 
   // Check if downloads are allowed
-  if (msg.type() == pb::remote::DOWNLOAD_SONGS && !allow_downloads_) {
-    DisconnectClient(pb::remote::Download_Forbidden);
+  if (msg.type() == cpb::remote::DOWNLOAD_SONGS && !allow_downloads_) {
+    DisconnectClient(cpb::remote::Download_Forbidden);
     return;
   }
 
-  if (msg.type() == pb::remote::DISCONNECT) {
+  if (msg.type() == cpb::remote::DISCONNECT) {
     client_->abort();
     qDebug() << "Client disconnected";
     return;
@@ -137,7 +137,7 @@
 
   // Check if the client has sent the correct auth code
   if (!authenticated_) {
-    DisconnectClient(pb::remote::Not_Authenticated);
+    DisconnectClient(cpb::remote::Not_Authenticated);
     return;
   }
 
@@ -145,9 +145,9 @@
   emit Parse(msg);
 }
 
-void RemoteClient::DisconnectClient(pb::remote::ReasonDisconnect reason) {
-  pb::remote::Message msg;
-  msg.set_type(pb::remote::DISCONNECT);
+void RemoteClient::DisconnectClient(cpb::remote::ReasonDisconnect reason) {
+  cpb::remote::Message msg;
+  msg.set_type(cpb::remote::DISCONNECT);
 
   msg.mutable_response_disconnect()->set_reason_disconnect(reason);
   SendDataToClient(&msg);
@@ -158,7 +158,7 @@
 }
 
 // Sends data to client without check if authenticated
-void RemoteClient::SendDataToClient(pb::remote::Message* msg) {
+void RemoteClient::SendDataToClient(cpb::remote::Message* msg) {
   // Set the default version
   msg->set_version(msg->default_instance().version());
 
@@ -185,7 +185,7 @@
   }
 }
 
-void RemoteClient::SendData(pb::remote::Message* msg) {
+void RemoteClient::SendData(cpb::remote::Message* msg) {
   // Check if client is authenticated before sending the data
   if (authenticated_) {
     SendDataToClient(msg);
diff -ur src/networkremote/remoteclient.h src/networkremote/remoteclient.h
--- a/src/networkremote/remoteclient.h	2020-09-23 22:34:08.000000000 -0400
+++ b/src/networkremote/remoteclient.h	2021-02-19 12:03:48.240473046 -0500
@@ -16,11 +16,11 @@
   ~RemoteClient();
 
   // This method checks if client is authenticated before sending the data
-  void SendData(pb::remote::Message* msg);
+  void SendData(cpb::remote::Message* msg);
   QAbstractSocket::SocketState State();
   void setDownloader(bool downloader);
   bool isDownloader() { return downloader_; }
-  void DisconnectClient(pb::remote::ReasonDisconnect reason);
+  void DisconnectClient(cpb::remote::ReasonDisconnect reason);
 
   SongSender* song_sender() { return song_sender_; }
 
@@ -28,13 +28,13 @@
   void IncomingData();
 
  signals:
-  void Parse(const pb::remote::Message& msg);
+  void Parse(const cpb::remote::Message& msg);
 
  private:
   void ParseMessage(const QByteArray& data);
 
   // Sends data to client without check if authenticated
-  void SendDataToClient(pb::remote::Message* msg);
+  void SendDataToClient(cpb::remote::Message* msg);
 
   Application* app_;
 
diff -ur src/networkremote/songsender.cpp src/networkremote/songsender.cpp
--- a/src/networkremote/songsender.cpp	2020-09-23 22:34:08.000000000 -0400
+++ b/src/networkremote/songsender.cpp	2021-02-19 12:03:48.240473046 -0500
@@ -67,29 +67,29 @@
   transcoder_->Cancel();
 }
 
-void SongSender::SendSongs(const pb::remote::RequestDownloadSongs& request) {
+void SongSender::SendSongs(const cpb::remote::RequestDownloadSongs& request) {
   Song current_song;
   if (app_->player()->GetCurrentItem()) {
     current_song = app_->player()->GetCurrentItem()->Metadata();
   }
 
   switch (request.download_item()) {
-    case pb::remote::CurrentItem: {
+    case cpb::remote::CurrentItem: {
       if (current_song.is_valid()) {
         DownloadItem item(current_song, 1, 1);
         download_queue_.append(item);
       }
       break;
     }
-    case pb::remote::ItemAlbum:
+    case cpb::remote::ItemAlbum:
       if (current_song.is_valid()) {
         SendAlbum(current_song);
       }
       break;
-    case pb::remote::APlaylist:
+    case cpb::remote::APlaylist:
       SendPlaylist(request.playlist_id());
       break;
-    case pb::remote::Urls:
+    case cpb::remote::Urls:
       SendUrls(request);
       break;
     default:
@@ -139,10 +139,10 @@
 
 void SongSender::SendTranscoderStatus() {
   // Send a message to the remote that we are converting files
-  pb::remote::Message msg;
-  msg.set_type(pb::remote::TRANSCODING_FILES);
+  cpb::remote::Message msg;
+  msg.set_type(cpb::remote::TRANSCODING_FILES);
 
-  pb::remote::ResponseTranscoderStatus* status =
+  cpb::remote::ResponseTranscoderStatus* status =
       msg.mutable_response_transcoder_status();
   status->set_processed(transcoder_map_.count());
   status->set_total(total_transcode_);
@@ -161,10 +161,10 @@
 }
 
 void SongSender::SendTotalFileSize() {
-  pb::remote::Message msg;
-  msg.set_type(pb::remote::DOWNLOAD_TOTAL_SIZE);
+  cpb::remote::Message msg;
+  msg.set_type(cpb::remote::DOWNLOAD_TOTAL_SIZE);
 
-  pb::remote::ResponseDownloadTotalSize* response =
+  cpb::remote::ResponseDownloadTotalSize* response =
       msg.mutable_response_download_total_size();
 
   response->set_file_count(download_queue_.size());
@@ -186,16 +186,16 @@
 }
 
 void SongSender::OfferNextSong() {
-  pb::remote::Message msg;
+  cpb::remote::Message msg;
 
   if (download_queue_.isEmpty()) {
-    msg.set_type(pb::remote::DOWNLOAD_QUEUE_EMPTY);
+    msg.set_type(cpb::remote::DOWNLOAD_QUEUE_EMPTY);
   } else {
     // Get the item and send the single song
     DownloadItem item = download_queue_.head();
 
-    msg.set_type(pb::remote::SONG_FILE_CHUNK);
-    pb::remote::ResponseSongFileChunk* chunk =
+    msg.set_type(cpb::remote::SONG_FILE_CHUNK);
+    cpb::remote::ResponseSongFileChunk* chunk =
         msg.mutable_response_song_file_chunk();
 
     // Open the file
@@ -247,10 +247,10 @@
   file.open(QIODevice::ReadOnly);
 
   QByteArray data;
-  pb::remote::Message msg;
-  pb::remote::ResponseSongFileChunk* chunk =
+  cpb::remote::Message msg;
+  cpb::remote::ResponseSongFileChunk* chunk =
       msg.mutable_response_song_file_chunk();
-  msg.set_type(pb::remote::SONG_FILE_CHUNK);
+  msg.set_type(cpb::remote::SONG_FILE_CHUNK);
 
   QImage null_image;
 
@@ -275,7 +275,7 @@
     // what file it receives.
     if (chunk_number == 1) {
       int i = app_->playlist_manager()->active()->current_row();
-      pb::remote::SongMetadata* song_metadata =
+      cpb::remote::SongMetadata* song_metadata =
           msg.mutable_response_song_file_chunk()->mutable_song_metadata();
       OutgoingDataCreator::CreateSong(download_item.song_, null_image, i,
                                       song_metadata);
@@ -346,7 +346,7 @@
   }
 }
 
-void SongSender::SendUrls(const pb::remote::RequestDownloadSongs& request) {
+void SongSender::SendUrls(const cpb::remote::RequestDownloadSongs& request) {
   SongList song_list;
 
   // First gather all valid songs
diff -ur src/networkremote/songsender.h src/networkremote/songsender.h
--- a/src/networkremote/songsender.h	2020-09-23 22:34:08.000000000 -0400
+++ b/src/networkremote/songsender.h	2021-02-19 12:03:48.240473046 -0500
@@ -30,7 +30,7 @@
   static const quint32 kFileChunkSize;
 
  public slots:
-  void SendSongs(const pb::remote::RequestDownloadSongs& request);
+  void SendSongs(const cpb::remote::RequestDownloadSongs& request);
   void ResponseSongOffer(bool accepted);
 
  private slots:
@@ -53,7 +53,7 @@
   void SendSingleSong(DownloadItem download_item);
   void SendAlbum(const Song& song);
   void SendPlaylist(int playlist_id);
-  void SendUrls(const pb::remote::RequestDownloadSongs& request);
+  void SendUrls(const cpb::remote::RequestDownloadSongs& request);
   void OfferNextSong();
   void SendTotalFileSize();
   void TranscodeLosslessFiles();
diff -ur tests/song_test.cpp tests/song_test.cpp
--- a/tests/song_test.cpp	2020-09-23 22:34:08.000000000 -0400
+++ b/tests/song_test.cpp	2021-02-19 12:03:48.240473046 -0500
@@ -45,7 +45,7 @@
   static Song ReadSongFromFile(const QString& filename) {
     TagReader tag_reader;
     Song song;
-    ::pb::tagreader::SongMetadata pb_song;
+    ::cpb::tagreader::SongMetadata pb_song;
 
     // We need to init protobuf object from a Song object, to have default
     // values initialized correctly. For example, Song's rating is -1 by
@@ -59,7 +59,7 @@
 
   static void WriteSongToFile(const Song& song, const QString& filename) {
     TagReader tag_reader;
-    ::pb::tagreader::SongMetadata pb_song;
+    ::cpb::tagreader::SongMetadata pb_song;
     song.ToProtobuf(&pb_song);
     tag_reader.SaveFile(filename, pb_song);
   }
@@ -67,14 +67,14 @@
   static void WriteSongStatisticsToFile(const Song& song,
                                         const QString& filename) {
     TagReader tag_reader;
-    ::pb::tagreader::SongMetadata pb_song;
+    ::cpb::tagreader::SongMetadata pb_song;
     song.ToProtobuf(&pb_song);
     tag_reader.SaveSongStatisticsToFile(filename, pb_song);
   }
 
   static void WriteSongRatingToFile(const Song& song, const QString& filename) {
     TagReader tag_reader;
-    ::pb::tagreader::SongMetadata pb_song;
+    ::cpb::tagreader::SongMetadata pb_song;
     song.ToProtobuf(&pb_song);
     tag_reader.SaveSongRatingToFile(filename, pb_song);
   }
