Attachment #811247 for bug #1141444

View | Details | Raw Unified | Return to bug 1141444
Collapse All | Expand All

Lines 1318-1324 bool TagReader::ReadCloudFile(const QUrl& download_url, const QString& title, Link Here

(-)a/ext/libclementine-tagreader/tagreader.cpp (-1 / +1 lines)
1318	qLog(Debug) << "Loading tags from" << title;	1318	qLog(Debug) << "Loading tags from" << title;
1319		1319
1320	std::unique_ptr<CloudStream> stream(new CloudStream(	1320	std::unique_ptr<CloudStream> stream(new CloudStream(
1321	download_url, title, size, authorisation_header, network_));	1321	download_url, title, size, authorisation_header, network_.get()));
1322	stream->Precache();	1322	stream->Precache();
1323	std::unique_ptr<TagLib::File> tag;	1323	std::unique_ptr<TagLib::File> tag;
1324	if (mime_type == "audio/mpeg" &&	1324	if (mime_type == "audio/mpeg" &&




#define TAGREADER_H

#include <QByteArray>
#include <QNetworkAccessManager>

#include <taglib/xiphcomment.h>

#include "config.h"
#include "tagreadermessages.pb.h"

class QNetworkAccessManager;
class QString;
class QTextCodec;
class QUrl;

      TagLib::ID3v2::Tag* tag);

  FileRefFactory* factory_;
  std::unique_ptr<QNetworkAccessManager> network_;

  const std::string kEmbeddedCover;
};




}

CrashSender::CrashSender(const QString& path)
    : network_(this),
      path_(path),
      file_(new QFile(path_, this)),
      progress_(nullptr) {}

  progress_->show();

  // We'll get a redirect first, so don't start POSTing data yet.
  QNetworkReply* reply = network_.get(QNetworkRequest(QUrl(kUploadURL)));
  connect(reply, SIGNAL(finished()), SLOT(RedirectFinished()));

  return true;

  progress_->setMaximum(form_data.size());

  // Upload the data
  reply = network_.post(req, form_data);
  connect(reply, SIGNAL(uploadProgress(qint64, qint64)),
          SLOT(UploadProgress(qint64)));
  connect(reply, SIGNAL(finished()), progress_, SLOT(close()));




#include <memory>

#include <QObject>
#include <QNetworkAccessManager>

class QFile;
class QNetworkAccessManager;
class QProgressDialog;

namespace google_breakpad {

 private:
  static const char* kUploadURL;

  QNetworkAccessManager network_;

  QString path_;
  QFile* file_;

Lines 670-676 void Database::BackupFile(const QString& filename) { Link Here

(-)a/src/core/database.cpp (-1 / +1 lines)
670	sqlite3* source_connection = nullptr;	670	sqlite3* source_connection = nullptr;
671	sqlite3* dest_connection = nullptr;	671	sqlite3* dest_connection = nullptr;
672		672
673	BOOST_SCOPE_EXIT((source_connection)(dest_connection)(task_id)(app_)) {	673	BOOST_SCOPE_EXIT((&source_connection)(&dest_connection)(task_id)(app_)) {
674	// Harmless to call sqlite3_close() with a nullptr pointer.	674	// Harmless to call sqlite3_close() with a nullptr pointer.
675	sqlite3_close(source_connection);	675	sqlite3_close(source_connection);
676	sqlite3_close(dest_connection);	676	sqlite3_close(dest_connection);

Lines 35-44 AlbumCoverFetcher::AlbumCoverFetcher(CoverProviders* cover_providers, Link Here

(-)a/src/covers/albumcoverfetcher.cpp (+6 lines)
35	network_(network ? network : new NetworkAccessManager(this)),	35	network_(network ? network : new NetworkAccessManager(this)),
36	next_id_(0),	36	next_id_(0),
37	request_starter_(new QTimer(this)) {	37	request_starter_(new QTimer(this)) {
		38	deleteNetwork = !network;
38	request_starter_->setInterval(1000);	39	request_starter_->setInterval(1000);
39	connect(request_starter_, SIGNAL(timeout()), SLOT(StartRequests()));	40	connect(request_starter_, SIGNAL(timeout()), SLOT(StartRequests()));
40	}	41	}
41		42
		43	AlbumCoverFetcher::~AlbumCoverFetcher() {
		44	if (deleteNetwork)
		45	delete network_;
		46	}
		47
42	quint64 AlbumCoverFetcher::FetchAlbumCover(const QString& artist,	48	quint64 AlbumCoverFetcher::FetchAlbumCover(const QString& artist,
43	const QString& album,	49	const QString& album,
44	bool fetchall) {	50	bool fetchall) {

Lines 86-92 class AlbumCoverFetcher : public QObject { Link Here

(-)a/src/covers/albumcoverfetcher.h (-1 / +2 lines)
86	public:	86	public:
87	AlbumCoverFetcher(CoverProviders* cover_providers, QObject* parent = nullptr,	87	AlbumCoverFetcher(CoverProviders* cover_providers, QObject* parent = nullptr,
88	QNetworkAccessManager* network = 0);	88	QNetworkAccessManager* network = 0);
89	virtual ~AlbumCoverFetcher() {}	89	virtual ~AlbumCoverFetcher();
90		90
91	static const int kMaxConcurrentRequests;	91	static const int kMaxConcurrentRequests;
92		92
Lines 110-115 class AlbumCoverFetcher : public QObject { Link Here
110	private:	110	private:
111	void AddRequest(const CoverSearchRequest& req);	111	void AddRequest(const CoverSearchRequest& req);
112		112
		113	bool deleteNetwork;
113	CoverProviders* cover_providers_;	114	CoverProviders* cover_providers_;
114	QNetworkAccessManager* network_;	115	QNetworkAccessManager* network_;
115	quint64 next_id_;	116	quint64 next_id_;

Lines 45-51 AlbumCoverFetcherSearch::AlbumCoverFetcherSearch( Link Here

(-)a/src/covers/albumcoverfetchersearch.cpp (-2 / +2 lines)
45	QObject* parent)	45	QObject* parent)
46	: QObject(parent),	46	: QObject(parent),
47	request_(request),	47	request_(request),
48	image_load_timeout_(new NetworkTimeouts(kImageLoadTimeoutMs, this)),	48	image_load_timeout_(kImageLoadTimeoutMs, this),
49	network_(network),	49	network_(network),
50	cancel_requested_(false) {	50	cancel_requested_(false) {
51	// we will terminate the search after kSearchTimeoutMs miliseconds if we are	51	// we will terminate the search after kSearchTimeoutMs miliseconds if we are
Lines 162-168 void AlbumCoverFetcherSearch::FetchMoreImages() { Link Here
162	SLOT(ProviderCoverFetchFinished(RedirectFollower*)),	162	SLOT(ProviderCoverFetchFinished(RedirectFollower*)),
163	image_reply);	163	image_reply);
164	pending_image_loads_[image_reply] = result.provider;	164	pending_image_loads_[image_reply] = result.provider;
165	image_load_timeout_->AddReply(image_reply);	165	image_load_timeout_.AddReply(image_reply);
166		166
167	statistics_.network_requests_made_++;	167	statistics_.network_requests_made_++;
168	}	168	}

Lines 22-27 Link Here

(-)a/src/covers/albumcoverfetchersearch.h (-1 / +2 lines)
22	#define COVERS_ALBUMCOVERFETCHERSEARCH_H_	22	#define COVERS_ALBUMCOVERFETCHERSEARCH_H_
23		23
24	#include "albumcoverfetcher.h"	24	#include "albumcoverfetcher.h"
		25	#include "core/network.h"
25		26
26	#include <QMap>	27	#include <QMap>
27	#include <QObject>	28	#include <QObject>
Lines 86-92 class AlbumCoverFetcherSearch : public QObject { Link Here
86		87
87	QMap<int, CoverProvider*> pending_requests_;	88	QMap<int, CoverProvider*> pending_requests_;
88	QMap<RedirectFollower*, QString> pending_image_loads_;	89	QMap<RedirectFollower*, QString> pending_image_loads_;
89	NetworkTimeouts* image_load_timeout_;	90	NetworkTimeouts image_load_timeout_;
90		91
91	// QMap is sorted by key (score). Values are (provider_name, image)	92	// QMap is sorted by key (score). Values are (provider_name, image)
92	typedef QPair<QString, QImage> CandidateImage;	93	typedef QPair<QString, QImage> CandidateImage;




    : QObject(parent),
      stop_requested_(false),
      next_id_(1),
      network_(this),
      connected_spotify_(false) {}

QString AlbumCoverLoader::ImageCacheDir() {

  if (filename.toLower().startsWith("http://") ||
      filename.toLower().startsWith("https://")) {
    QUrl url(filename);
    QNetworkReply* reply = network_.get(QNetworkRequest(url));
    NewClosure(reply, SIGNAL(finished()), this,
               SLOT(RemoteFetchFinished(QNetworkReply*)), reply);


    }
    QNetworkRequest request = reply->request();
    request.setUrl(redirect.toUrl());
    QNetworkReply* redirected_reply = network_.get(request);
    NewClosure(redirected_reply, SIGNAL(finished()), this,
               SLOT(RemoteFetchFinished(QNetworkReply*)), redirected_reply);






#include "albumcoverloaderoptions.h"
#include "config.h"
#include "core/network.h"
#include "core/song.h"

#include <QImage>

#include <QQueue>
#include <QUrl>

class NetworkAccessManager;
class QNetworkReply;

class AlbumCoverLoader : public QObject {

  QMap<QString, Task> remote_spotify_tasks_;
  quint64 next_id_;

  NetworkAccessManager network_;

  bool connected_spotify_;






DiscogsCoverProvider::DiscogsCoverProvider(QObject* parent)
    : CoverProvider("Discogs", false, parent),
      network_(this) {}

bool DiscogsCoverProvider::StartSearch(const QString& artist,
                                       const QString& album, int s_id) {

                         QUrl::toPercentEncoding(signature.toBase64()));

  url.setQuery(url_query);
  QNetworkReply* reply = network_.get(QNetworkRequest(url));

  NewClosure(reply, SIGNAL(error(QNetworkReply::NetworkError)), this,
             SLOT(SearchRequestError(QNetworkReply::NetworkError,

                         QUrl::toPercentEncoding(signature.toBase64()));

  url.setQuery(url_query);
  QNetworkReply* reply = network_.get(QNetworkRequest(url));

  NewClosure(reply, SIGNAL(error(QNetworkReply::NetworkError)), this,
             SLOT(ReleaseRequestError(QNetworkReply::NetworkError,

Lines 23-28 Link Here

(-)a/src/covers/discogscoverprovider.h (-1 / +2 lines)
23	#include <QXmlStreamReader>	23	#include <QXmlStreamReader>
24		24
25	#include "coverprovider.h"	25	#include "coverprovider.h"
		26	#include "core/network.h"
26		27
27	class QNetworkAccessManager;	28	class QNetworkAccessManager;
28		29
Lines 75-81 class DiscogsCoverProvider : public CoverProvider { Link Here
75	static const char* kAccessKeyB64;	76	static const char* kAccessKeyB64;
76	static const char* kSecretKeyB64;	77	static const char* kSecretKeyB64;
77		78
78	QNetworkAccessManager* network_;	79	NetworkAccessManager network_;
79	QHash<int, DiscogsCoverSearchContext*> requests_search_;	80	QHash<int, DiscogsCoverSearchContext*> requests_search_;
80	QHash<int, DiscogsCoverReleaseContext*> requests_release_;	81	QHash<int, DiscogsCoverReleaseContext*> requests_release_;
81		82

Lines 63-69 quint64 KittenLoader::LoadKitten(const AlbumCoverLoaderOptions& options) { Link Here

(-)a/src/covers/kittenloader.cpp (-1 / +1 lines)
63		63
64	void KittenLoader::FetchMoreKittens() {	64	void KittenLoader::FetchMoreKittens() {
65	QNetworkRequest req = QNetworkRequest(QUrl(kFlickrKittenUrl));	65	QNetworkRequest req = QNetworkRequest(QUrl(kFlickrKittenUrl));
66	QNetworkReply* reply = network_->get(req);	66	QNetworkReply* reply = network_.get(req);
67	NewClosure(reply, SIGNAL(finished()), this,	67	NewClosure(reply, SIGNAL(finished()), this,
68	SLOT(KittensRetrieved(QNetworkReply*)), reply);	68	SLOT(KittensRetrieved(QNetworkReply*)), reply);
69	}	69	}





MusicbrainzCoverProvider::MusicbrainzCoverProvider(QObject* parent)
    : CoverProvider("MusicBrainz", true, parent),
      network_(this) {}

bool MusicbrainzCoverProvider::StartSearch(const QString& artist,
                                           const QString& album, int id) {

  url.setQuery(url_query);
  QNetworkRequest request(url);

  QNetworkReply* reply = network_.get(request);
  NewClosure(reply, SIGNAL(finished()), this,
             SLOT(ReleaseSearchFinished(QNetworkReply*, int)), reply, id);



  for (const QString& release_id : releases) {
    QUrl url(QString(kAlbumCoverUrl).arg(release_id));
    QNetworkReply* reply = network_.head(QNetworkRequest(url));
    image_checks_.insert(id, reply);
    NewClosure(reply, SIGNAL(finished()), this, SLOT(ImageCheckFinished(int)),
               id);




#define COVERS_MUSICBRAINZCOVERPROVIDER_H_

#include "coverprovider.h"
#include "core/network.h"

#include <QMultiMap>

class QNetworkAccessManager;
class QNetworkReply;

class MusicbrainzCoverProvider : public CoverProvider {

  void ImageCheckFinished(int id);

 private:
  NetworkAccessManager network_;
  QMultiMap<int, QNetworkReply*> image_checks_;
  QMap<int, QString> cover_names_;
};




    QNetworkRequest request(url);
    AddAuthorizationHeader(&request);

    QNetworkReply* reply = network_.get(request);
    NewClosure(reply, SIGNAL(finished()), this,
               SLOT(FetchUserInfoFinished(QNetworkReply*)), reply);
  } else {

  url.setQuery(url_query);
  QNetworkRequest request(url);
  AddAuthorizationHeader(&request);
  QNetworkReply* reply = network_.get(request);
  NewClosure(reply, SIGNAL(finished()), this,
             SLOT(InitialiseEventsFinished(QNetworkReply*)), reply);
}

  url.setQuery(url_query);
  QNetworkRequest request(url);
  AddAuthorizationHeader(&request);
  QNetworkReply* reply = network_.get(request);
  NewClosure(reply, SIGNAL(finished()), this,
             SLOT(FetchFolderItemsFinished(QNetworkReply*, int)), reply,
             folder_id);

  QUrl content_url(QString(kFileContent).arg(file_id));
  QNetworkRequest request(content_url);
  AddAuthorizationHeader(&request);
  QNetworkReply* reply = network_.get(request);
  return reply;
}


  url.setQuery(url_query);
  QNetworkRequest request(url);
  AddAuthorizationHeader(&request);
  QNetworkReply* reply = network_.get(request);
  NewClosure(reply, SIGNAL(finished()), this,
             SLOT(FetchEventsFinished(QNetworkReply*)), reply);
}

Lines 43-49 CloudFileService::CloudFileService(Application* app, InternetModel* parent, Link Here

(-)a/src/internet/core/cloudfileservice.cpp (-1 / +1 lines)
43	SettingsDialog::Page settings_page)	43	SettingsDialog::Page settings_page)
44	: InternetService(service_name, app, parent, parent),	44	: InternetService(service_name, app, parent, parent),
45	root_(nullptr),	45	root_(nullptr),
46	network_(new NetworkAccessManager(this)),	46	network_(this),
47	library_sort_model_(new QSortFilterProxyModel(this)),	47	library_sort_model_(new QSortFilterProxyModel(this)),
48	playlist_manager_(app->playlist_manager()),	48	playlist_manager_(app->playlist_manager()),
49	task_manager_(app->task_manager()),	49	task_manager_(app->task_manager()),

Lines 26-31 Link Here

(-)a/src/internet/core/cloudfileservice.h (-1 / +2 lines)
26		26
27	#include <QMenu>	27	#include <QMenu>
28		28
		29	#include "core/network.h"
29	#include "core/tagreaderclient.h"	30	#include "core/tagreaderclient.h"
30	#include "ui/albumcovermanager.h"	31	#include "ui/albumcovermanager.h"
31		32
Lines 77-83 signals: Link Here
77		78
78	protected:	79	protected:
79	QStandardItem* root_;	80	QStandardItem* root_;
80	NetworkAccessManager* network_;	81	NetworkAccessManager network_;
81		82
82	LibraryBackend* library_backend_;	83	LibraryBackend* library_backend_;
83	LibraryModel* library_model_;	84	LibraryModel* library_model_;




DigitallyImportedClient::DigitallyImportedClient(const QString& service_name,
                                                 QObject* parent)
    : QObject(parent),
      network_(this),
      service_name_(service_name) {}

void DigitallyImportedClient::SetAuthorisationHeader(

  QByteArray postdata = "username=" + QUrl::toPercentEncoding(username) +
                        "&password=" + QUrl::toPercentEncoding(password);

  return network_.post(req, postdata);
}

DigitallyImportedClient::AuthReply DigitallyImportedClient::ParseAuthReply(

  QNetworkRequest req(QUrl(QString(kChannelListUrl).arg(service_name_)));
  SetAuthorisationHeader(&req);

  return network_.get(req);
}

DigitallyImportedClient::ChannelList DigitallyImportedClient::ParseChannelList(

Lines 25-30 Link Here

(-)a/src/internet/digitally/digitallyimportedclient.h (-1 / +3 lines)
25	#include <QSettings>	25	#include <QSettings>
26	#include <QUrl>	26	#include <QUrl>
27		27
		28	#include "core/network.h"
		29
28	class QNetworkAccessManager;	30	class QNetworkAccessManager;
29	class QNetworkReply;	31	class QNetworkReply;
30	class QNetworkRequest;	32	class QNetworkRequest;
Lines 75-81 class DigitallyImportedClient : public QObject { Link Here
75	void SetAuthorisationHeader(QNetworkRequest* req) const;	77	void SetAuthorisationHeader(QNetworkRequest* req) const;
76		78
77	private:	79	private:
78	QNetworkAccessManager* network_;	80	NetworkAccessManager network_;
79		81
80	QString service_name_;	82	QString service_name_;
81	};	83	};

Lines 53-59 DigitallyImportedServiceBase::DigitallyImportedServiceBase( Link Here

(-)a/src/internet/digitally/digitallyimportedservicebase.cpp (-2 / +2 lines)
53	icon_(icon),	53	icon_(icon),
54	service_description_(description),	54	service_description_(description),
55	api_service_name_(api_service_name),	55	api_service_name_(api_service_name),
56	network_(new NetworkAccessManager(this)),	56	network_(this),
57	url_handler_(new DigitallyImportedUrlHandler(app, this)),	57	url_handler_(new DigitallyImportedUrlHandler(app, this)),
58	premium_audio_type_(2),	58	premium_audio_type_(2),
59	has_premium_(has_premium),	59	has_premium_(has_premium),
Lines 229-235 void DigitallyImportedServiceBase::LoadStation(const QString& key) { Link Here
229		229
230	qLog(Debug) << "Getting playlist URL" << playlist_url;	230	qLog(Debug) << "Getting playlist URL" << playlist_url;
231		231
232	QNetworkReply* reply = network_->get(QNetworkRequest(playlist_url));	232	QNetworkReply* reply = network_.get(QNetworkRequest(playlist_url));
233	NewClosure(reply, SIGNAL(finished()), this,	233	NewClosure(reply, SIGNAL(finished()), this,
234	SLOT(LoadPlaylistFinished(QNetworkReply*)), reply);	234	SLOT(LoadPlaylistFinished(QNetworkReply*)), reply);
235	}	235	}

Lines 23-28 Link Here

(-)a/src/internet/digitally/digitallyimportedservicebase.h (-1 / +2 lines)
23	#include <memory>	23	#include <memory>
24		24
25	#include "core/cachedlist.h"	25	#include "core/cachedlist.h"
		26	#include "core/network.h"
26	#include "digitallyimportedclient.h"	27	#include "digitallyimportedclient.h"
27	#include "internet/core/internetservice.h"	28	#include "internet/core/internetservice.h"
28		29
Lines 91-97 class DigitallyImportedServiceBase : public InternetService { Link Here
91		92
92	QStringList premium_playlists_;	93	QStringList premium_playlists_;
93		94
94	QNetworkAccessManager* network_;	95	NetworkAccessManager network_;
95	DigitallyImportedUrlHandler* url_handler_;	96	DigitallyImportedUrlHandler* url_handler_;
96		97
97	int premium_audio_type_;	98	int premium_audio_type_;

Lines 55-61 const char* IcecastService::kHomepage = "http://dir.xiph.org/"; Link Here

(-)a/src/internet/icecast/icecastservice.cpp (-2 / +2 lines)
55		55
56	IcecastService::IcecastService(Application* app, InternetModel* parent)	56	IcecastService::IcecastService(Application* app, InternetModel* parent)
57	: InternetService(kServiceName, app, parent, parent),	57	: InternetService(kServiceName, app, parent, parent),
58	network_(new NetworkAccessManager(this)),	58	network_(this),
59	context_menu_(nullptr),	59	context_menu_(nullptr),
60	backend_(nullptr),	60	backend_(nullptr),
61	model_(nullptr),	61	model_(nullptr),
Lines 108-114 void IcecastService::RequestDirectory(const QUrl& url, int task_id) { Link Here
108	req.setAttribute(QNetworkRequest::CacheLoadControlAttribute,	108	req.setAttribute(QNetworkRequest::CacheLoadControlAttribute,
109	QNetworkRequest::AlwaysNetwork);	109	QNetworkRequest::AlwaysNetwork);
110		110
111	QNetworkReply* reply = network_->get(req);	111	QNetworkReply* reply = network_.get(req);
112	NewClosure(reply, SIGNAL(finished()), this,	112	NewClosure(reply, SIGNAL(finished()), this,
113	SLOT(DownloadDirectoryFinished(QNetworkReply*, int)), reply,	113	SLOT(DownloadDirectoryFinished(QNetworkReply*, int)), reply,
114	task_id);	114	task_id);

Lines 22-27 Link Here

(-)a/src/internet/icecast/icecastservice.h (-1 / +2 lines)
22	#define INTERNET_ICECAST_ICECASTSERVICE_H_	22	#define INTERNET_ICECAST_ICECASTSERVICE_H_
23		23
24	#include "internet/core/internetservice.h"	24	#include "internet/core/internetservice.h"
		25	#include "core/network.h"
25		26
26	#include <QXmlStreamReader>	27	#include <QXmlStreamReader>
27		28
Lines 72-78 class IcecastService : public InternetService { Link Here
72	IcecastBackend::Station ReadStation(QXmlStreamReader* reader) const;	73	IcecastBackend::Station ReadStation(QXmlStreamReader* reader) const;
73		74
74	QStandardItem* root_;	75	QStandardItem* root_;
75	NetworkAccessManager* network_;	76	NetworkAccessManager network_;
76	QMenu* context_menu_;	77	QMenu* context_menu_;
77		78
78	IcecastBackend* backend_;	79	IcecastBackend* backend_;




#define INTERNET_INTERGALACTICFM_INTERGALACTICFMSERVICE_H_

#include <QXmlStreamReader>
#include <QNetworkAccessManager>

#include "internet/core/internetservice.h"
#include "core/cachedlist.h"

class IntergalacticFMUrlHandler;

class QNetworkAccessManager;
class QNetworkReply;
class QMenu;


  void ShowContextMenu(const QPoint& global_pos);

  PlaylistItem::Options playlistitem_options() const;
  QNetworkAccessManager* network() const { return network_.get(); }

  void ReloadSettings();


  QStandardItem* root_;
  QMenu* context_menu_;

  std::unique_ptr<QNetworkAccessManager> network_;

  CachedList<Stream> streams_;


Lines 80-86 const int JamendoService::kApproxDatabaseSize = 450000; Link Here

(-)a/src/internet/jamendo/jamendoservice.cpp (-2 / +2 lines)
80		80
81	JamendoService::JamendoService(Application* app, InternetModel* parent)	81	JamendoService::JamendoService(Application* app, InternetModel* parent)
82	: InternetService(kServiceName, app, parent, parent),	82	: InternetService(kServiceName, app, parent, parent),
83	network_(new NetworkAccessManager(this)),	83	network_(this),
84	context_menu_(nullptr),	84	context_menu_(nullptr),
85	library_backend_(nullptr),	85	library_backend_(nullptr),
86	library_filter_(nullptr),	86	library_filter_(nullptr),
Lines 189-195 void JamendoService::DownloadDirectory() { Link Here
189	req.setAttribute(QNetworkRequest::CacheLoadControlAttribute,	189	req.setAttribute(QNetworkRequest::CacheLoadControlAttribute,
190	QNetworkRequest::AlwaysNetwork);	190	QNetworkRequest::AlwaysNetwork);
191		191
192	QNetworkReply* reply = network_->get(req);	192	QNetworkReply* reply = network_.get(req);
193	connect(reply, SIGNAL(finished()), SLOT(DownloadDirectoryFinished()));	193	connect(reply, SIGNAL(finished()), SLOT(DownloadDirectoryFinished()));
194	connect(reply, SIGNAL(downloadProgress(qint64, qint64)),	194	connect(reply, SIGNAL(downloadProgress(qint64, qint64)),
195	SLOT(DownloadDirectoryProgress(qint64, qint64)));	195	SLOT(DownloadDirectoryProgress(qint64, qint64)));




#define INTERNET_JAMENDO_JAMENDOSERVICE_H_

#include "internet/core/internetservice.h"
#include "core/network.h"

#include <QXmlStreamReader>


class LibraryFilterWidget;
class LibraryModel;
class LibrarySearchProvider;
class NetworkAccessManager;
class SearchProvider;

class QIODevice;

  void SearchProviderToggled(const SearchProvider* provider, bool enabled);

 private:
  NetworkAccessManager network_;

  QMenu* context_menu_;


Lines 31-38 Link Here

(-)a/src/internet/podcasts/gpoddersearchpage.cpp (-2 / +2 lines)
31	GPodderSearchPage::GPodderSearchPage(Application* app, QWidget* parent)	31	GPodderSearchPage::GPodderSearchPage(Application* app, QWidget* parent)
32	: AddPodcastPage(app, parent),	32	: AddPodcastPage(app, parent),
33	ui_(new Ui_GPodderSearchPage),	33	ui_(new Ui_GPodderSearchPage),
34	network_(new NetworkAccessManager(this)),	34	network_(this),
35	api_(new mygpo::ApiRequest(network_)) {	35	api_(new mygpo::ApiRequest(&network_)) {
36	ui_->setupUi(this);	36	ui_->setupUi(this);
37	connect(ui_->search, SIGNAL(clicked()), SLOT(SearchClicked()));	37	connect(ui_->search, SIGNAL(clicked()), SLOT(SearchClicked()));
38	setWindowIcon(IconLoader::Load("mygpo", IconLoader::Provider));	38	setWindowIcon(IconLoader::Load("mygpo", IconLoader::Provider));




#define INTERNET_PODCASTS_GPODDERSEARCHPAGE_H_

#include "addpodcastpage.h"
#include "core/network.h"

#include <ApiRequest.h>

class QNetworkAccessManager;

class Ui_GPodderSearchPage;

class GPodderSearchPage : public AddPodcastPage {

 private:
  Ui_GPodderSearchPage* ui_;

  NetworkAccessManager network_;
  mygpo::ApiRequest* api_;
};





GPodderSync::GPodderSync(Application* app, QObject* parent)
    : QObject(parent),
      app_(app),
      network_(this),
      backend_(app_->podcast_backend()),
      loader_(new PodcastUrlLoader(this)),
      get_updates_timer_(new QTimer(this)),

  last_successful_get_ = s.value("gpodder_last_get").toDateTime();

  if (!username_.isEmpty() && !password_.isEmpty()) {
    api_.reset(new mygpo::ApiRequest(username_, password_, &network_));
  }
}

QNetworkReply* GPodderSync::Login(const QString& username,
                                  const QString& password,
                                  const QString& device_name) {
  api_.reset(new mygpo::ApiRequest(username, password, &network_));

  QNetworkReply* reply = api_->renameDevice(
      username, DeviceId(), device_name,

Lines 21-26 Link Here

(-)a/src/internet/podcasts/gpoddersync.h (-1 / +2 lines)
21	#define INTERNET_PODCASTS_GPODDERSYNC_H_	21	#define INTERNET_PODCASTS_GPODDERSYNC_H_
22		22
23	#include "podcastepisode.h"	23	#include "podcastepisode.h"
		24	#include "core/network.h"
24		25
25	#include <QDateTime>	26	#include <QDateTime>
26	#include <QObject>	27	#include <QObject>
Lines 100-106 class GPodderSync : public QObject { Link Here
100		101
101	private:	102	private:
102	Application* app_;	103	Application* app_;
103	QNetworkAccessManager* network_;	104	NetworkAccessManager network_;
104	QScopedPointer<mygpo::ApiRequest> api_;	105	QScopedPointer<mygpo::ApiRequest> api_;
105		106
106	PodcastBackend* backend_;	107	PodcastBackend* backend_;

Lines 30-37 const int GPodderTopTagsPage::kMaxTagCount = 100; Link Here

(-)a/src/internet/podcasts/gpoddertoptagspage.cpp (-2 / +2 lines)
30		30
31	GPodderTopTagsPage::GPodderTopTagsPage(Application* app, QWidget* parent)	31	GPodderTopTagsPage::GPodderTopTagsPage(Application* app, QWidget* parent)
32	: AddPodcastPage(app, parent),	32	: AddPodcastPage(app, parent),
33	network_(new NetworkAccessManager(this)),	33	network_(this),
34	api_(new mygpo::ApiRequest(network_)),	34	api_(new mygpo::ApiRequest(&network_)),
35	done_initial_load_(false) {	35	done_initial_load_(false) {
36	setWindowTitle(tr("gpodder.net directory"));	36	setWindowTitle(tr("gpodder.net directory"));
37	setWindowIcon(IconLoader::Load("mygpo", IconLoader::Provider));	37	setWindowIcon(IconLoader::Load("mygpo", IconLoader::Provider));

Lines 25-32 Link Here

(-)a/src/internet/podcasts/gpoddertoptagspage.h (-3 / +2 lines)
25	#include <ApiRequest.h>	25	#include <ApiRequest.h>
26		26
27	#include "addpodcastpage.h"	27	#include "addpodcastpage.h"
28		28	#include "core/network.h"
29	class QNetworkAccessManager;
30		29
31	class GPodderTopTagsPage : public AddPodcastPage {	30	class GPodderTopTagsPage : public AddPodcastPage {
32	Q_OBJECT	31	Q_OBJECT
Lines 45-51 class GPodderTopTagsPage : public AddPodcastPage { Link Here
45	void TagListFailed(mygpo::TagListPtr tag_list);	44	void TagListFailed(mygpo::TagListPtr tag_list);
46		45
47	private:	46	private:
48	QNetworkAccessManager* network_;	47	NetworkAccessManager network_;
49	mygpo::ApiRequest* api_;	48	mygpo::ApiRequest* api_;
50		49
51	bool done_initial_load_;	50	bool done_initial_load_;

Lines 41-47 const char* ITunesSearchPage::kUrlBase = Link Here

(-)a/src/internet/podcasts/itunessearchpage.cpp (-2 / +2 lines)
41	ITunesSearchPage::ITunesSearchPage(Application* app, QWidget* parent)	41	ITunesSearchPage::ITunesSearchPage(Application* app, QWidget* parent)
42	: AddPodcastPage(app, parent),	42	: AddPodcastPage(app, parent),
43	ui_(new Ui_ITunesSearchPage),	43	ui_(new Ui_ITunesSearchPage),
44	network_(new NetworkAccessManager(this)) {	44	network_(this) {
45	ui_->setupUi(this);	45	ui_->setupUi(this);
46	connect(ui_->search, SIGNAL(clicked()), SLOT(SearchClicked()));	46	connect(ui_->search, SIGNAL(clicked()), SLOT(SearchClicked()));
47	setWindowIcon(IconLoader::Load("itunes", IconLoader::Provider));	47	setWindowIcon(IconLoader::Load("itunes", IconLoader::Provider));
Lines 57-63 void ITunesSearchPage::SearchClicked() { Link Here
57	url_query.addQueryItem("term", ui_->query->text());	57	url_query.addQueryItem("term", ui_->query->text());
58	url.setQuery(url_query);	58	url.setQuery(url_query);
59		59
60	QNetworkReply* reply = network_->get(QNetworkRequest(url));	60	QNetworkReply* reply = network_.get(QNetworkRequest(url));
61	NewClosure(reply, SIGNAL(finished()), this,	61	NewClosure(reply, SIGNAL(finished()), this,
62	SLOT(SearchFinished(QNetworkReply*)), reply);	62	SLOT(SearchFinished(QNetworkReply*)), reply);
63	}	63	}




#define INTERNET_PODCASTS_ITUNESSEARCHPAGE_H_

#include "addpodcastpage.h"
#include "core/network.h"

class Ui_ITunesSearchPage;

class QNetworkAccessManager;
class QNetworkReply;

class ITunesSearchPage : public AddPodcastPage {

 private:
  Ui_ITunesSearchPage* ui_;

  NetworkAccessManager network_;
};

#endif  // INTERNET_PODCASTS_ITUNESSEARCHPAGE_H_

Lines 43-50 Task::Task(PodcastEpisode episode, QFile* file, PodcastBackend* backend) Link Here

(-)a/src/internet/podcasts/podcastdownloader.cpp (-3 / +3 lines)
43	episode_(episode),	43	episode_(episode),
44	req_(QNetworkRequest(episode.url())),	44	req_(QNetworkRequest(episode.url())),
45	backend_(backend),	45	backend_(backend),
46	network_(new NetworkAccessManager(this)),	46	network_(this),
47	repl(new RedirectFollower(network_->get(req_))) {	47	repl(new RedirectFollower(network_.get(req_))) {
48	connect(repl.get(), SIGNAL(readyRead()), SLOT(reading()));	48	connect(repl.get(), SIGNAL(readyRead()), SLOT(reading()));
49	connect(repl.get(), SIGNAL(finished()), SLOT(finishedInternal()));	49	connect(repl.get(), SIGNAL(finished()), SLOT(finishedInternal()));
50	connect(repl.get(), SIGNAL(downloadProgress(qint64, qint64)),	50	connect(repl.get(), SIGNAL(downloadProgress(qint64, qint64)),
Lines 115-121 PodcastDownloader::PodcastDownloader(Application* app, QObject* parent) Link Here
115	: QObject(parent),	115	: QObject(parent),
116	app_(app),	116	app_(app),
117	backend_(app_->podcast_backend()),	117	backend_(app_->podcast_backend()),
118	network_(new NetworkAccessManager(this)),	118	network_(this),
119	disallowed_filename_characters_("[^a-zA-Z0-9_~ -]"),	119	disallowed_filename_characters_("[^a-zA-Z0-9_~ -]"),
120	auto_download_(false) {	120	auto_download_(false) {
121	connect(backend_, SIGNAL(EpisodesAdded(PodcastEpisodeList)),	121	connect(backend_, SIGNAL(EpisodesAdded(PodcastEpisodeList)),




class Application;
class PodcastBackend;

class QNetworkAccessManager;

namespace PodcastDownload {
  enum State { NotDownloading, Queued, Downloading, Finished };
}

  PodcastEpisode episode_;
  QNetworkRequest req_;
  PodcastBackend* backend_;
  NetworkAccessManager network_;
  std::unique_ptr<RedirectFollower> repl;
};


 private:
  Application* app_;
  PodcastBackend* backend_;
  NetworkAccessManager network_;

  QRegExp disallowed_filename_characters_;


Lines 32-38 const int PodcastUrlLoader::kMaxRedirects = 5; Link Here

(-)a/src/internet/podcasts/podcasturlloader.cpp (-2 / +2 lines)
32		32
33	PodcastUrlLoader::PodcastUrlLoader(QObject* parent)	33	PodcastUrlLoader::PodcastUrlLoader(QObject* parent)
34	: QObject(parent),	34	: QObject(parent),
35	network_(new NetworkAccessManager(this)),	35	network_(this),
36	parser_(new PodcastParser),	36	parser_(new PodcastParser),
37	html_link_re_("<link (.*)>"),	37	html_link_re_("<link (.*)>"),
38	html_link_rel_re_("rel\\s=\\s['\"]?\\s*alternate"),	38	html_link_rel_re_("rel\\s=\\s['\"]?\\s*alternate"),
Lines 125-131 void PodcastUrlLoader::NextRequest(const QUrl& url, RequestState* state) { Link Here
125	QNetworkRequest req(url);	125	QNetworkRequest req(url);
126	req.setAttribute(QNetworkRequest::CacheLoadControlAttribute,	126	req.setAttribute(QNetworkRequest::CacheLoadControlAttribute,
127	QNetworkRequest::AlwaysNetwork);	127	QNetworkRequest::AlwaysNetwork);
128	QNetworkReply* network_reply = network_->get(req);	128	QNetworkReply* network_reply = network_.get(req);
129		129
130	NewClosure(network_reply, SIGNAL(finished()), this,	130	NewClosure(network_reply, SIGNAL(finished()), this,
131	SLOT(RequestFinished(RequestState, QNetworkReply)), state,	131	SLOT(RequestFinished(RequestState, QNetworkReply)), state,





#include "opmlcontainer.h"
#include "podcast.h"
#include "core/network.h"

class PodcastParser;

class QNetworkAccessManager;
class QNetworkReply;

class PodcastUrlLoaderReply : public QObject {

  void NextRequest(const QUrl& url, RequestState* state);

 private:
  NetworkAccessManager network_;
  PodcastParser* parser_;

  QRegExp html_link_re_;




  QNetworkRequest request(url);
  AddAuthorizationHeader(&request);

  QNetworkReply* reply = network_.post(request, url_query.toString().toLatin1());
  WaitForSignal(reply, SIGNAL(finished()));

  if (!CheckReply(&reply)) {

  QUrl url(server_ + kListReposUrl);
  QNetworkRequest request(url);
  AddAuthorizationHeader(&request);
  QNetworkReply* reply = network_.get(request);

  NewClosure(reply, SIGNAL(finished()), this,
             SLOT(GetLibrariesFinished(QNetworkReply*)), reply);


  QNetworkRequest request(url);
  AddAuthorizationHeader(&request);
  QNetworkReply* reply = network_.get(request);

  return reply;
}


  QNetworkRequest request(content_url);
  AddAuthorizationHeader(&request);
  QNetworkReply* reply = network_.get(request);

  return reply;
}


  QNetworkRequest request(content_url);
  AddAuthorizationHeader(&request);
  QNetworkReply* reply = network_.get(request);

  return reply;
}

      (*reply)->deleteLater();

      // We execute the reply again
      *reply = network_.get((*reply)->request());
      WaitForSignal(*reply, SIGNAL(finished()));

      return CheckReply(reply, ++tries);




  QNetworkRequest request(url);
  AddAuthorizationHeader(&request);

  QNetworkReply* reply = network_.get(request);
  NewClosure(reply, SIGNAL(finished()), this,
             SLOT(FetchUserInfoFinished(QNetworkReply*)), reply);
}

  QNetworkRequest request(url);
  AddAuthorizationHeader(&request);

  QNetworkReply* reply = network_.get(request);
  NewClosure(reply, SIGNAL(finished()), this,
             SLOT(ListFilesFinished(QNetworkReply*)), reply);
}

  QUrl url(QString(kSkydriveBase) + file_id);
  QNetworkRequest request(url);
  AddAuthorizationHeader(&request);
  std::unique_ptr<QNetworkReply> reply(network_.get(request));
  WaitForSignal(reply.get(), SIGNAL(finished()));

  QJsonObject json_response = QJsonDocument::fromBinaryData(reply.get()->readAll()).object();

Lines 57-63 SpotifyBlobDownloader::SpotifyBlobDownloader(const QString& version, Link Here

(-)a/src/internet/spotify/spotifyblobdownloader.cpp (-2 / +2 lines)
57	: QObject(parent),	57	: QObject(parent),
58	version_(version),	58	version_(version),
59	path_(path),	59	path_(path),
60	network_(new NetworkAccessManager(this)),	60	network_(this),
61	progress_(new QProgressDialog(tr("Downloading Spotify plugin"),	61	progress_(new QProgressDialog(tr("Downloading Spotify plugin"),
62	tr("Cancel"), 0, 0)) {	62	tr("Cancel"), 0, 0)) {
63	progress_->setWindowTitle(QCoreApplication::applicationName());	63	progress_->setWindowTitle(QCoreApplication::applicationName());
Lines 95-101 void SpotifyBlobDownloader::Start() { Link Here
95	filename);	95	filename);
96	qLog(Info) << "Downloading" << url;	96	qLog(Info) << "Downloading" << url;
97		97
98	QNetworkReply* reply = network_->get(QNetworkRequest(url));	98	QNetworkReply* reply = network_.get(QNetworkRequest(url));
99	connect(reply, SIGNAL(finished()), SLOT(ReplyFinished()));	99	connect(reply, SIGNAL(finished()), SLOT(ReplyFinished()));
100	connect(reply, SIGNAL(downloadProgress(qint64, qint64)),	100	connect(reply, SIGNAL(downloadProgress(qint64, qint64)),
101	SLOT(ReplyProgress()));	101	SLOT(ReplyProgress()));

Lines 23-29 Link Here

(-)a/src/internet/spotify/spotifyblobdownloader.h (-2 / +3 lines)
23	#include <QMap>	23	#include <QMap>
24	#include <QObject>	24	#include <QObject>
25		25
26	class QNetworkAccessManager;	26	#include "core/network.h"
		27
27	class QNetworkReply;	28	class QNetworkReply;
28	class QProgressDialog;	29	class QProgressDialog;
29		30
Lines 61-67 signals: Link Here
61	QString version_;	62	QString version_;
62	QString path_;	63	QString path_;
63		64
64	QNetworkAccessManager* network_;	65	NetworkAccessManager network_;
65	QList<QNetworkReply*> replies_;	66	QList<QNetworkReply*> replies_;
66		67
67	QProgressDialog* progress_;	68	QProgressDialog* progress_;

Lines 151-157 SubsonicService::SubsonicService(Application* app, InternetModel* parent) Link Here

(-)a/src/internet/subsonic/subsonicservice.cpp (-1 / +3 lines)
151	IconLoader::Load("subsonic", IconLoader::Provider), true, app_, this));	151	IconLoader::Load("subsonic", IconLoader::Provider), true, app_, this));
152	}	152	}
153		153
154	SubsonicService::~SubsonicService() {}	154	SubsonicService::~SubsonicService() {
		155	delete network_;
		156	}
155		157
156	QStandardItem* SubsonicService::CreateRootItem() {	158	QStandardItem* SubsonicService::CreateRootItem() {
157	root_ = new QStandardItem(IconLoader::Load("subsonic", IconLoader::Provider),	159	root_ = new QStandardItem(IconLoader::Load("subsonic", IconLoader::Provider),





AcoustidClient::AcoustidClient(QObject* parent)
    : QObject(parent),
      network_(this),
      timeouts_(kDefaultTimeout, this) {}

void AcoustidClient::SetTimeout(int msec) { timeouts_.SetTimeout(msec); }

void AcoustidClient::Start(int id, const QString& fingerprint,
                           int duration_msec) {

  url.setQuery(url_query);
  QNetworkRequest req(url);

  QNetworkReply* reply = network_.get(req);
  NewClosure(reply, SIGNAL(finished()), this,
             SLOT(RequestFinished(QNetworkReply*, int)), reply, id);
  requests_[id] = reply;

  timeouts_.AddReply(reply);
}

void AcoustidClient::Cancel(int id) { delete requests_.take(id); }




#include <QMap>
#include <QObject>

#include "core/network.h"

class QNetworkAccessManager;
class QNetworkReply;

class AcoustidClient : public QObject {

  static const char* kUrl;
  static const int kDefaultTimeout;

  NetworkAccessManager network_;
  NetworkTimeouts timeouts_;
  QMap<int, QNetworkReply*> requests_;
};


Lines 42-48 MusicBrainzClient::MusicBrainzClient(QObject* parent, Link Here

(-)a/src/musicbrainz/musicbrainzclient.cpp (-3 / +12 lines)
42	QNetworkAccessManager* network)	42	QNetworkAccessManager* network)
43	: QObject(parent),	43	: QObject(parent),
44	network_(network ? network : new NetworkAccessManager(this)),	44	network_(network ? network : new NetworkAccessManager(this)),
45	timeouts_(new NetworkTimeouts(kDefaultTimeout, this)) {}	45	timeouts_(kDefaultTimeout, this) {
		46	// TODO: replace by shared_ptr
		47	deleteNetwork = !network;
		48	}
		49
		50	MusicBrainzClient::~MusicBrainzClient()
		51	{
		52	if (deleteNetwork)
		53	delete network_;
		54	}
46		55
47	void MusicBrainzClient::Start(int id, const QStringList& mbid_list) {	56	void MusicBrainzClient::Start(int id, const QStringList& mbid_list) {
48	typedef QPair<QString, QString> Param;	57	typedef QPair<QString, QString> Param;
Lines 64-70 void MusicBrainzClient::Start(int id, const QStringList& mbid_list) { Link Here
64	request_number++);	73	request_number++);
65	requests_.insert(id, reply);	74	requests_.insert(id, reply);
66		75
67	timeouts_->AddReply(reply);	76	timeouts_.AddReply(reply);
68		77
69	if (request_number >= kMaxRequestPerTrack) {	78	if (request_number >= kMaxRequestPerTrack) {
70	break;	79	break;
Lines 89-95 void MusicBrainzClient::StartDiscIdRequest(const QString& discid) { Link Here
89	SLOT(DiscIdRequestFinished(const QString&, QNetworkReply*)),	98	SLOT(DiscIdRequestFinished(const QString&, QNetworkReply*)),
90	discid, reply);	99	discid, reply);
91		100
92	timeouts_->AddReply(reply);	101	timeouts_.AddReply(reply);
93	}	102	}
94		103
95	void MusicBrainzClient::Cancel(int id) { delete requests_.take(id); }	104	void MusicBrainzClient::Cancel(int id) { delete requests_.take(id); }




#include <QObject>
#include <QXmlStreamReader>

#include "core/network.h"

class QNetworkAccessManager;
class QNetworkReply;

  // is not transferred.
  MusicBrainzClient(QObject* parent = nullptr,
                    QNetworkAccessManager* network = nullptr);
  ~MusicBrainzClient();

  struct Result {
    Result() : duration_msec_(0), track_(0), year_(-1) {}

  static const int kDefaultTimeout;
  static const int kMaxRequestPerTrack;

  bool deleteNetwork;
  QNetworkAccessManager* network_;
  NetworkTimeouts timeouts_;
  QMultiMap<int, QNetworkReply*> requests_;
  // Results we received so far, kept here until all the replies are finished
  QMap<int, QList<PendingResults>> pending_results_;




const int UltimateLyricsProvider::kRedirectLimit = 5;

UltimateLyricsProvider::UltimateLyricsProvider()
    : network_(this),
      relevance_(0),
      redirect_count_(0),
      url_hop_(false) {}

  // Fetch the URL, follow redirects
  metadata_ = metadata;
  redirect_count_ = 0;
  QNetworkReply* reply = network_.get(QNetworkRequest(url));
  requests_[reply] = id;
  connect(reply, SIGNAL(finished()), SLOT(LyricsFetched()));
}

    }

    redirect_count_++;
    QNetworkReply* reply = network_.get(QNetworkRequest(target));
    requests_[reply] = id;
    connect(reply, SIGNAL(finished()), SLOT(LyricsFetched()));
    return;

        url_hop_ = true;
        QUrl url(content);
        qLog(Debug) << "Next url hop: " << url;
        QNetworkReply* reply = network_.get(QNetworkRequest(url));
        requests_[reply] = id;
        connect(reply, SIGNAL(finished()), SLOT(LyricsFetched()));
        return;

Lines 23-30 Link Here

(-)a/src/songinfo/ultimatelyricsprovider.h (-3 / +2 lines)
23	#include <QStringList>	23	#include <QStringList>
24		24
25	#include "songinfoprovider.h"	25	#include "songinfoprovider.h"
26		26	#include "core/network.h"
27	class NetworkAccessManager;
28		27
29	class QNetworkReply;	28	class QNetworkReply;
30		29
Lines 85-91 class UltimateLyricsProvider : public SongInfoProvider { Link Here
85	void ReplaceFields(const Song& metadata, QString* text) const;	84	void ReplaceFields(const Song& metadata, QString* text) const;
86		85
87	private:	86	private:
88	NetworkAccessManager* network_;	87	NetworkAccessManager network_;
89	QMap<QNetworkReply*, int> requests_;	88	QMap<QNetworkReply*, int> requests_;
90		89
91	QString name_;	90	QString name_;

Lines 30-36 Link Here

(-)a/src/ui/coverfromurldialog.cpp (-2 / +2 lines)
30	CoverFromURLDialog::CoverFromURLDialog(QWidget* parent)	30	CoverFromURLDialog::CoverFromURLDialog(QWidget* parent)
31	: QDialog(parent),	31	: QDialog(parent),
32	ui_(new Ui_CoverFromURLDialog),	32	ui_(new Ui_CoverFromURLDialog),
33	network_(new NetworkAccessManager(this)) {	33	network_(this) {
34	ui_->setupUi(this);	34	ui_->setupUi(this);
35	ui_->busy->hide();	35	ui_->busy->hide();
36	}	36	}
Lines 56-62 void CoverFromURLDialog::accept() { Link Here
56	QNetworkRequest network_request =	56	QNetworkRequest network_request =
57	QNetworkRequest(QUrl::fromUserInput(ui_->url->text()));	57	QNetworkRequest(QUrl::fromUserInput(ui_->url->text()));
58		58
59	QNetworkReply* reply = network_->get(network_request);	59	QNetworkReply* reply = network_.get(network_request);
60	connect(reply, SIGNAL(finished()), SLOT(LoadCoverFromURLFinished()));	60	connect(reply, SIGNAL(finished()), SLOT(LoadCoverFromURLFinished()));
61	}	61	}
62		62




#include <QDialog>
#include <QImage>

#include "core/network.h"

class Song;
class Ui_CoverFromURLDialog;


 private:
  Ui_CoverFromURLDialog* ui_;

  NetworkAccessManager network_;
  QImage last_image_;
};

- 

Return to bug 1141444

Lines 19-31 Link Here

(-)a/ext/libclementine-tagreader/tagreader.h (-2 / +2 lines)
19	#define TAGREADER_H	19	#define TAGREADER_H
20		20
21	#include <QByteArray>	21	#include <QByteArray>
		22	#include <QNetworkAccessManager>
22		23
23	#include <taglib/xiphcomment.h>	24	#include <taglib/xiphcomment.h>
24		25
25	#include "config.h"	26	#include "config.h"
26	#include "tagreadermessages.pb.h"	27	#include "tagreadermessages.pb.h"
27		28
28	class QNetworkAccessManager;
29	class QString;	29	class QString;
30	class QTextCodec;	30	class QTextCodec;
31	class QUrl;	31	class QUrl;
Lines 120-126 class TagReader { Link Here
120	TagLib::ID3v2::Tag* tag);	120	TagLib::ID3v2::Tag* tag);
121		121
122	FileRefFactory* factory_;	122	FileRefFactory* factory_;
123	QNetworkAccessManager* network_;	123	std::unique_ptr<QNetworkAccessManager> network_;
124		124
125	const std::string kEmbeddedCover;	125	const std::string kEmbeddedCover;
126	};	126	};

Lines 99-105 bool CrashReporting::Handler(const char* dump_path, const char* minidump_id, Link Here

(-)a/src/core/crashreporting.cpp (-3 / +3 lines)
99	}	99	}
100		100
101	CrashSender::CrashSender(const QString& path)	101	CrashSender::CrashSender(const QString& path)
102	: network_(new QNetworkAccessManager(this)),	102	: network_(this),
103	path_(path),	103	path_(path),
104	file_(new QFile(path_, this)),	104	file_(new QFile(path_, this)),
105	progress_(nullptr) {}	105	progress_(nullptr) {}
Lines 128-134 bool CrashSender::Start() { Link Here
128	progress_->show();	128	progress_->show();
129		129
130	// We'll get a redirect first, so don't start POSTing data yet.	130	// We'll get a redirect first, so don't start POSTing data yet.
131	QNetworkReply* reply = network_->get(QNetworkRequest(QUrl(kUploadURL)));	131	QNetworkReply* reply = network_.get(QNetworkRequest(QUrl(kUploadURL)));
132	connect(reply, SIGNAL(finished()), SLOT(RedirectFinished()));	132	connect(reply, SIGNAL(finished()), SLOT(RedirectFinished()));
133		133
134	return true;	134	return true;
Lines 183-189 void CrashSender::RedirectFinished() { Link Here
183	progress_->setMaximum(form_data.size());	183	progress_->setMaximum(form_data.size());
184		184
185	// Upload the data	185	// Upload the data
186	reply = network_->post(req, form_data);	186	reply = network_.post(req, form_data);
187	connect(reply, SIGNAL(uploadProgress(qint64, qint64)),	187	connect(reply, SIGNAL(uploadProgress(qint64, qint64)),
188	SLOT(UploadProgress(qint64)));	188	SLOT(UploadProgress(qint64)));
189	connect(reply, SIGNAL(finished()), progress_, SLOT(close()));	189	connect(reply, SIGNAL(finished()), progress_, SLOT(close()));

Lines 23-31 Link Here

(-)a/src/core/crashreporting.h (-2 / +2 lines)
23	#include <memory>	23	#include <memory>
24		24
25	#include <QObject>	25	#include <QObject>
		26	#include <QNetworkAccessManager>
26		27
27	class QFile;	28	class QFile;
28	class QNetworkAccessManager;
29	class QProgressDialog;	29	class QProgressDialog;
30		30
31	namespace google_breakpad {	31	namespace google_breakpad {
Lines 85-91 class CrashSender : public QObject { Link Here
85	private:	85	private:
86	static const char* kUploadURL;	86	static const char* kUploadURL;
87		87
88	QNetworkAccessManager* network_;	88	QNetworkAccessManager network_;
89		89
90	QString path_;	90	QString path_;
91	QFile* file_;	91	QFile* file_;

Lines 42-48 AlbumCoverLoader::AlbumCoverLoader(QObject* parent) Link Here

(-)a/src/covers/albumcoverloader.cpp (-3 / +3 lines)
42	: QObject(parent),	42	: QObject(parent),
43	stop_requested_(false),	43	stop_requested_(false),
44	next_id_(1),	44	next_id_(1),
45	network_(new NetworkAccessManager(this)),	45	network_(this),
46	connected_spotify_(false) {}	46	connected_spotify_(false) {}
47		47
48	QString AlbumCoverLoader::ImageCacheDir() {	48	QString AlbumCoverLoader::ImageCacheDir() {
Lines 172-178 AlbumCoverLoader::TryLoadResult AlbumCoverLoader::TryLoadImage( Link Here
172	if (filename.toLower().startsWith("http://") \|\|	172	if (filename.toLower().startsWith("http://") \|\|
173	filename.toLower().startsWith("https://")) {	173	filename.toLower().startsWith("https://")) {
174	QUrl url(filename);	174	QUrl url(filename);
175	QNetworkReply* reply = network_->get(QNetworkRequest(url));	175	QNetworkReply* reply = network_.get(QNetworkRequest(url));
176	NewClosure(reply, SIGNAL(finished()), this,	176	NewClosure(reply, SIGNAL(finished()), this,
177	SLOT(RemoteFetchFinished(QNetworkReply*)), reply);	177	SLOT(RemoteFetchFinished(QNetworkReply*)), reply);
178		178
Lines 239-245 void AlbumCoverLoader::RemoteFetchFinished(QNetworkReply* reply) { Link Here
239	}	239	}
240	QNetworkRequest request = reply->request();	240	QNetworkRequest request = reply->request();
241	request.setUrl(redirect.toUrl());	241	request.setUrl(redirect.toUrl());
242	QNetworkReply* redirected_reply = network_->get(request);	242	QNetworkReply* redirected_reply = network_.get(request);
243	NewClosure(redirected_reply, SIGNAL(finished()), this,	243	NewClosure(redirected_reply, SIGNAL(finished()), this,
244	SLOT(RemoteFetchFinished(QNetworkReply*)), redirected_reply);	244	SLOT(RemoteFetchFinished(QNetworkReply*)), redirected_reply);
245		245

Lines 23-28 Link Here

(-)a/src/covers/albumcoverloader.h (-2 / +2 lines)
23		23
24	#include "albumcoverloaderoptions.h"	24	#include "albumcoverloaderoptions.h"
25	#include "config.h"	25	#include "config.h"
		26	#include "core/network.h"
26	#include "core/song.h"	27	#include "core/song.h"
27		28
28	#include <QImage>	29	#include <QImage>
Lines 31-37 Link Here
31	#include <QQueue>	32	#include <QQueue>
32	#include <QUrl>	33	#include <QUrl>
33		34
34	class NetworkAccessManager;
35	class QNetworkReply;	35	class QNetworkReply;
36		36
37	class AlbumCoverLoader : public QObject {	37	class AlbumCoverLoader : public QObject {
Lines 109-115 class AlbumCoverLoader : public QObject { Link Here
109	QMap<QString, Task> remote_spotify_tasks_;	109	QMap<QString, Task> remote_spotify_tasks_;
110	quint64 next_id_;	110	quint64 next_id_;
111		111
112	NetworkAccessManager* network_;	112	NetworkAccessManager network_;
113		113
114	bool connected_spotify_;	114	bool connected_spotify_;
115		115

Lines 47-53 const char* DiscogsCoverProvider::kSecretKeyB64 = Link Here

(-)a/src/covers/discogscoverprovider.cpp (-3 / +3 lines)
47		47
48	DiscogsCoverProvider::DiscogsCoverProvider(QObject* parent)	48	DiscogsCoverProvider::DiscogsCoverProvider(QObject* parent)
49	: CoverProvider("Discogs", false, parent),	49	: CoverProvider("Discogs", false, parent),
50	network_(new NetworkAccessManager(this)) {}	50	network_(this) {}
51		51
52	bool DiscogsCoverProvider::StartSearch(const QString& artist,	52	bool DiscogsCoverProvider::StartSearch(const QString& artist,
53	const QString& album, int s_id) {	53	const QString& album, int s_id) {
Lines 128-134 void DiscogsCoverProvider::SendSearchRequest(DiscogsCoverSearchContext* s_ctx) { Link Here
128	QUrl::toPercentEncoding(signature.toBase64()));	128	QUrl::toPercentEncoding(signature.toBase64()));
129		129
130	url.setQuery(url_query);	130	url.setQuery(url_query);
131	QNetworkReply* reply = network_->get(QNetworkRequest(url));	131	QNetworkReply* reply = network_.get(QNetworkRequest(url));
132		132
133	NewClosure(reply, SIGNAL(error(QNetworkReply::NetworkError)), this,	133	NewClosure(reply, SIGNAL(error(QNetworkReply::NetworkError)), this,
134	SLOT(SearchRequestError(QNetworkReply::NetworkError,	134	SLOT(SearchRequestError(QNetworkReply::NetworkError,
Lines 175-181 void DiscogsCoverProvider::SendReleaseRequest( Link Here
175	QUrl::toPercentEncoding(signature.toBase64()));	175	QUrl::toPercentEncoding(signature.toBase64()));
176		176
177	url.setQuery(url_query);	177	url.setQuery(url_query);
178	QNetworkReply* reply = network_->get(QNetworkRequest(url));	178	QNetworkReply* reply = network_.get(QNetworkRequest(url));
179		179
180	NewClosure(reply, SIGNAL(error(QNetworkReply::NetworkError)), this,	180	NewClosure(reply, SIGNAL(error(QNetworkReply::NetworkError)), this,
181	SLOT(ReleaseRequestError(QNetworkReply::NetworkError,	181	SLOT(ReleaseRequestError(QNetworkReply::NetworkError,

Lines 38-44 static const char* kAlbumCoverUrl = Link Here

(-)a/src/covers/musicbrainzcoverprovider.cpp (-3 / +3 lines)
38		38
39	MusicbrainzCoverProvider::MusicbrainzCoverProvider(QObject* parent)	39	MusicbrainzCoverProvider::MusicbrainzCoverProvider(QObject* parent)
40	: CoverProvider("MusicBrainz", true, parent),	40	: CoverProvider("MusicBrainz", true, parent),
41	network_(new NetworkAccessManager(this)) {}	41	network_(this) {}
42		42
43	bool MusicbrainzCoverProvider::StartSearch(const QString& artist,	43	bool MusicbrainzCoverProvider::StartSearch(const QString& artist,
44	const QString& album, int id) {	44	const QString& album, int id) {
Lines 53-59 bool MusicbrainzCoverProvider::StartSearch(const QString& artist, Link Here
53	url.setQuery(url_query);	53	url.setQuery(url_query);
54	QNetworkRequest request(url);	54	QNetworkRequest request(url);
55		55
56	QNetworkReply* reply = network_->get(request);	56	QNetworkReply* reply = network_.get(request);
57	NewClosure(reply, SIGNAL(finished()), this,	57	NewClosure(reply, SIGNAL(finished()), this,
58	SLOT(ReleaseSearchFinished(QNetworkReply*, int)), reply, id);	58	SLOT(ReleaseSearchFinished(QNetworkReply*, int)), reply, id);
59		59
Lines 80-86 void MusicbrainzCoverProvider::ReleaseSearchFinished(QNetworkReply* reply, Link Here
80		80
81	for (const QString& release_id : releases) {	81	for (const QString& release_id : releases) {
82	QUrl url(QString(kAlbumCoverUrl).arg(release_id));	82	QUrl url(QString(kAlbumCoverUrl).arg(release_id));
83	QNetworkReply* reply = network_->head(QNetworkRequest(url));	83	QNetworkReply* reply = network_.head(QNetworkRequest(url));
84	image_checks_.insert(id, reply);	84	image_checks_.insert(id, reply);
85	NewClosure(reply, SIGNAL(finished()), this, SLOT(ImageCheckFinished(int)),	85	NewClosure(reply, SIGNAL(finished()), this, SLOT(ImageCheckFinished(int)),
86	id);	86	id);

Lines 20-29 Link Here

(-)a/src/covers/musicbrainzcoverprovider.h (-2 / +2 lines)
20	#define COVERS_MUSICBRAINZCOVERPROVIDER_H_	20	#define COVERS_MUSICBRAINZCOVERPROVIDER_H_
21		21
22	#include "coverprovider.h"	22	#include "coverprovider.h"
		23	#include "core/network.h"
23		24
24	#include <QMultiMap>	25	#include <QMultiMap>
25		26
26	class QNetworkAccessManager;
27	class QNetworkReply;	27	class QNetworkReply;
28		28
29	class MusicbrainzCoverProvider : public CoverProvider {	29	class MusicbrainzCoverProvider : public CoverProvider {
Lines 40-46 class MusicbrainzCoverProvider : public CoverProvider { Link Here
40	void ImageCheckFinished(int id);	40	void ImageCheckFinished(int id);
41		41
42	private:	42	private:
43	QNetworkAccessManager* network_;	43	NetworkAccessManager network_;
44	QMultiMap<int, QNetworkReply*> image_checks_;	44	QMultiMap<int, QNetworkReply*> image_checks_;
45	QMap<int, QString> cover_names_;	45	QMap<int, QString> cover_names_;
46	};	46	};

Lines 110-116 void BoxService::ConnectFinished(OAuthenticator* oauth) { Link Here

(-)a/src/internet/box/boxservice.cpp (-5 / +5 lines)
110	QNetworkRequest request(url);	110	QNetworkRequest request(url);
111	AddAuthorizationHeader(&request);	111	AddAuthorizationHeader(&request);
112		112
113	QNetworkReply* reply = network_->get(request);	113	QNetworkReply* reply = network_.get(request);
114	NewClosure(reply, SIGNAL(finished()), this,	114	NewClosure(reply, SIGNAL(finished()), this,
115	SLOT(FetchUserInfoFinished(QNetworkReply*)), reply);	115	SLOT(FetchUserInfoFinished(QNetworkReply*)), reply);
116	} else {	116	} else {
Lines 169-175 void BoxService::InitialiseEventsCursor() { Link Here
169	url.setQuery(url_query);	169	url.setQuery(url_query);
170	QNetworkRequest request(url);	170	QNetworkRequest request(url);
171	AddAuthorizationHeader(&request);	171	AddAuthorizationHeader(&request);
172	QNetworkReply* reply = network_->get(request);	172	QNetworkReply* reply = network_.get(request);
173	NewClosure(reply, SIGNAL(finished()), this,	173	NewClosure(reply, SIGNAL(finished()), this,
174	SLOT(InitialiseEventsFinished(QNetworkReply*)), reply);	174	SLOT(InitialiseEventsFinished(QNetworkReply*)), reply);
175	}	175	}
Lines 201-207 void BoxService::FetchRecursiveFolderItems(const int folder_id, Link Here
201	url.setQuery(url_query);	201	url.setQuery(url_query);
202	QNetworkRequest request(url);	202	QNetworkRequest request(url);
203	AddAuthorizationHeader(&request);	203	AddAuthorizationHeader(&request);
204	QNetworkReply* reply = network_->get(request);	204	QNetworkReply* reply = network_.get(request);
205	NewClosure(reply, SIGNAL(finished()), this,	205	NewClosure(reply, SIGNAL(finished()), this,
206	SLOT(FetchFolderItemsFinished(QNetworkReply*, int)), reply,	206	SLOT(FetchFolderItemsFinished(QNetworkReply*, int)), reply,
207	folder_id);	207	folder_id);
Lines 255-261 QNetworkReply* BoxService::FetchContentUrlForFile(const QString& file_id) { Link Here
255	QUrl content_url(QString(kFileContent).arg(file_id));	255	QUrl content_url(QString(kFileContent).arg(file_id));
256	QNetworkRequest request(content_url);	256	QNetworkRequest request(content_url);
257	AddAuthorizationHeader(&request);	257	AddAuthorizationHeader(&request);
258	QNetworkReply* reply = network_->get(request);	258	QNetworkReply* reply = network_.get(request);
259	return reply;	259	return reply;
260	}	260	}
261		261
Lines 281-287 void BoxService::UpdateFilesFromCursor(const QString& cursor) { Link Here
281	url.setQuery(url_query);	281	url.setQuery(url_query);
282	QNetworkRequest request(url);	282	QNetworkRequest request(url);
283	AddAuthorizationHeader(&request);	283	AddAuthorizationHeader(&request);
284	QNetworkReply* reply = network_->get(request);	284	QNetworkReply* reply = network_.get(request);
285	NewClosure(reply, SIGNAL(finished()), this,	285	NewClosure(reply, SIGNAL(finished()), this,
286	SLOT(FetchEventsFinished(QNetworkReply*)), reply);	286	SLOT(FetchEventsFinished(QNetworkReply*)), reply);
287	}	287	}

Lines 45-51 const char* DigitallyImportedClient::kChannelListUrl = Link Here

(-)a/src/internet/digitally/digitallyimportedclient.cpp (-3 / +3 lines)
45	DigitallyImportedClient::DigitallyImportedClient(const QString& service_name,	45	DigitallyImportedClient::DigitallyImportedClient(const QString& service_name,
46	QObject* parent)	46	QObject* parent)
47	: QObject(parent),	47	: QObject(parent),
48	network_(new NetworkAccessManager(this)),	48	network_(this),
49	service_name_(service_name) {}	49	service_name_(service_name) {}
50		50
51	void DigitallyImportedClient::SetAuthorisationHeader(	51	void DigitallyImportedClient::SetAuthorisationHeader(
Lines 65-71 QNetworkReply* DigitallyImportedClient::Auth(const QString& username, Link Here
65	QByteArray postdata = "username=" + QUrl::toPercentEncoding(username) +	65	QByteArray postdata = "username=" + QUrl::toPercentEncoding(username) +
66	"&password=" + QUrl::toPercentEncoding(password);	66	"&password=" + QUrl::toPercentEncoding(password);
67		67
68	return network_->post(req, postdata);	68	return network_.post(req, postdata);
69	}	69	}
70		70
71	DigitallyImportedClient::AuthReply DigitallyImportedClient::ParseAuthReply(	71	DigitallyImportedClient::AuthReply DigitallyImportedClient::ParseAuthReply(
Lines 115-121 QNetworkReply* DigitallyImportedClient::GetChannelList() { Link Here
115	QNetworkRequest req(QUrl(QString(kChannelListUrl).arg(service_name_)));	115	QNetworkRequest req(QUrl(QString(kChannelListUrl).arg(service_name_)));
116	SetAuthorisationHeader(&req);	116	SetAuthorisationHeader(&req);
117		117
118	return network_->get(req);	118	return network_.get(req);
119	}	119	}
120		120
121	DigitallyImportedClient::ChannelList DigitallyImportedClient::ParseChannelList(	121	DigitallyImportedClient::ChannelList DigitallyImportedClient::ParseChannelList(

Lines 21-33 Link Here

(-)a/src/internet/intergalacticfm/intergalacticfmservice.h (-3 / +3 lines)
21	#define INTERNET_INTERGALACTICFM_INTERGALACTICFMSERVICE_H_	21	#define INTERNET_INTERGALACTICFM_INTERGALACTICFMSERVICE_H_
22		22
23	#include <QXmlStreamReader>	23	#include <QXmlStreamReader>
		24	#include <QNetworkAccessManager>
24		25
25	#include "internet/core/internetservice.h"	26	#include "internet/core/internetservice.h"
26	#include "core/cachedlist.h"	27	#include "core/cachedlist.h"
27		28
28	class IntergalacticFMUrlHandler;	29	class IntergalacticFMUrlHandler;
29		30
30	class QNetworkAccessManager;
31	class QNetworkReply;	31	class QNetworkReply;
32	class QMenu;	32	class QMenu;
33		33
Lines 64-70 class IntergalacticFMServiceBase : public InternetService { Link Here
64	void ShowContextMenu(const QPoint& global_pos);	64	void ShowContextMenu(const QPoint& global_pos);
65		65
66	PlaylistItem::Options playlistitem_options() const;	66	PlaylistItem::Options playlistitem_options() const;
67	QNetworkAccessManager* network() const { return network_; }	67	QNetworkAccessManager* network() const { return network_.get(); }
68		68
69	void ReloadSettings();	69	void ReloadSettings();
70		70
Lines 93-99 signals: Link Here
93	QStandardItem* root_;	93	QStandardItem* root_;
94	QMenu* context_menu_;	94	QMenu* context_menu_;
95		95
96	QNetworkAccessManager* network_;	96	std::unique_ptr<QNetworkAccessManager> network_;
97		97
98	CachedList<Stream> streams_;	98	CachedList<Stream> streams_;
99		99

Lines 23-28 Link Here

(-)a/src/internet/jamendo/jamendoservice.h (-2 / +2 lines)
23	#define INTERNET_JAMENDO_JAMENDOSERVICE_H_	23	#define INTERNET_JAMENDO_JAMENDOSERVICE_H_
24		24
25	#include "internet/core/internetservice.h"	25	#include "internet/core/internetservice.h"
		26	#include "core/network.h"
26		27
27	#include <QXmlStreamReader>	28	#include <QXmlStreamReader>
28		29
Lines 32-38 class LibraryBackend; Link Here
32	class LibraryFilterWidget;	33	class LibraryFilterWidget;
33	class LibraryModel;	34	class LibraryModel;
34	class LibrarySearchProvider;	35	class LibrarySearchProvider;
35	class NetworkAccessManager;
36	class SearchProvider;	36	class SearchProvider;
37		37
38	class QIODevice;	38	class QIODevice;
Lines 103-109 class JamendoService : public InternetService { Link Here
103	void SearchProviderToggled(const SearchProvider* provider, bool enabled);	103	void SearchProviderToggled(const SearchProvider* provider, bool enabled);
104		104
105	private:	105	private:
106	NetworkAccessManager* network_;	106	NetworkAccessManager network_;
107		107
108	QMenu* context_menu_;	108	QMenu* context_menu_;
109		109

Lines 21-31 Link Here

(-)a/src/internet/podcasts/gpoddersearchpage.h (-3 / +2 lines)
21	#define INTERNET_PODCASTS_GPODDERSEARCHPAGE_H_	21	#define INTERNET_PODCASTS_GPODDERSEARCHPAGE_H_
22		22
23	#include "addpodcastpage.h"	23	#include "addpodcastpage.h"
		24	#include "core/network.h"
24		25
25	#include <ApiRequest.h>	26	#include <ApiRequest.h>
26		27
27	class QNetworkAccessManager;
28
29	class Ui_GPodderSearchPage;	28	class Ui_GPodderSearchPage;
30		29
31	class GPodderSearchPage : public AddPodcastPage {	30	class GPodderSearchPage : public AddPodcastPage {
Lines 45-51 class GPodderSearchPage : public AddPodcastPage { Link Here
45	private:	44	private:
46	Ui_GPodderSearchPage* ui_;	45	Ui_GPodderSearchPage* ui_;
47		46
48	QNetworkAccessManager* network_;	47	NetworkAccessManager network_;
49	mygpo::ApiRequest* api_;	48	mygpo::ApiRequest* api_;
50	};	49	};
51		50

Lines 42-48 const int GPodderSync::kGetUpdatesInterval = Link Here

(-)a/src/internet/podcasts/gpoddersync.cpp (-3 / +3 lines)
42	GPodderSync::GPodderSync(Application* app, QObject* parent)	42	GPodderSync::GPodderSync(Application* app, QObject* parent)
43	: QObject(parent),	43	: QObject(parent),
44	app_(app),	44	app_(app),
45	network_(new NetworkAccessManager(this)),	45	network_(this),
46	backend_(app_->podcast_backend()),	46	backend_(app_->podcast_backend()),
47	loader_(new PodcastUrlLoader(this)),	47	loader_(new PodcastUrlLoader(this)),
48	get_updates_timer_(new QTimer(this)),	48	get_updates_timer_(new QTimer(this)),
Lines 97-110 void GPodderSync::ReloadSettings() { Link Here
97	last_successful_get_ = s.value("gpodder_last_get").toDateTime();	97	last_successful_get_ = s.value("gpodder_last_get").toDateTime();
98		98
99	if (!username_.isEmpty() && !password_.isEmpty()) {	99	if (!username_.isEmpty() && !password_.isEmpty()) {
100	api_.reset(new mygpo::ApiRequest(username_, password_, network_));	100	api_.reset(new mygpo::ApiRequest(username_, password_, &network_));
101	}	101	}
102	}	102	}
103		103
104	QNetworkReply* GPodderSync::Login(const QString& username,	104	QNetworkReply* GPodderSync::Login(const QString& username,
105	const QString& password,	105	const QString& password,
106	const QString& device_name) {	106	const QString& device_name) {
107	api_.reset(new mygpo::ApiRequest(username, password, network_));	107	api_.reset(new mygpo::ApiRequest(username, password, &network_));
108		108
109	QNetworkReply* reply = api_->renameDevice(	109	QNetworkReply* reply = api_->renameDevice(
110	username, DeviceId(), device_name,	110	username, DeviceId(), device_name,

Lines 21-30 Link Here

(-)a/src/internet/podcasts/itunessearchpage.h (-2 / +2 lines)
21	#define INTERNET_PODCASTS_ITUNESSEARCHPAGE_H_	21	#define INTERNET_PODCASTS_ITUNESSEARCHPAGE_H_
22		22
23	#include "addpodcastpage.h"	23	#include "addpodcastpage.h"
		24	#include "core/network.h"
24		25
25	class Ui_ITunesSearchPage;	26	class Ui_ITunesSearchPage;
26		27
27	class QNetworkAccessManager;
28	class QNetworkReply;	28	class QNetworkReply;
29		29
30	class ITunesSearchPage : public AddPodcastPage {	30	class ITunesSearchPage : public AddPodcastPage {
Lines 45-51 class ITunesSearchPage : public AddPodcastPage { Link Here
45	private:	45	private:
46	Ui_ITunesSearchPage* ui_;	46	Ui_ITunesSearchPage* ui_;
47		47
48	QNetworkAccessManager* network_;	48	NetworkAccessManager network_;
49	};	49	};
50		50
51	#endif // INTERNET_PODCASTS_ITUNESSEARCHPAGE_H_	51	#endif // INTERNET_PODCASTS_ITUNESSEARCHPAGE_H_

Lines 41-48 Link Here

(-)a/src/internet/podcasts/podcastdownloader.h (-4 / +2 lines)
41	class Application;	41	class Application;
42	class PodcastBackend;	42	class PodcastBackend;
43		43
44	class QNetworkAccessManager;
45
46	namespace PodcastDownload {	44	namespace PodcastDownload {
47	enum State { NotDownloading, Queued, Downloading, Finished };	45	enum State { NotDownloading, Queued, Downloading, Finished };
48	}	46	}
Lines 72-78 class Task : public QObject { Link Here
72	PodcastEpisode episode_;	70	PodcastEpisode episode_;
73	QNetworkRequest req_;	71	QNetworkRequest req_;
74	PodcastBackend* backend_;	72	PodcastBackend* backend_;
75	std::unique_ptr<NetworkAccessManager> network_;	73	NetworkAccessManager network_;
76	std::unique_ptr<RedirectFollower> repl;	74	std::unique_ptr<RedirectFollower> repl;
77	};	75	};
78		76
Lines 111-117 class PodcastDownloader : public QObject { Link Here
111	private:	109	private:
112	Application* app_;	110	Application* app_;
113	PodcastBackend* backend_;	111	PodcastBackend* backend_;
114	QNetworkAccessManager* network_;	112	NetworkAccessManager network_;
115		113
116	QRegExp disallowed_filename_characters_;	114	QRegExp disallowed_filename_characters_;
117		115

Lines 25-34 Link Here

(-)a/src/internet/podcasts/podcasturlloader.h (-2 / +2 lines)
25		25
26	#include "opmlcontainer.h"	26	#include "opmlcontainer.h"
27	#include "podcast.h"	27	#include "podcast.h"
		28	#include "core/network.h"
28		29
29	class PodcastParser;	30	class PodcastParser;
30		31
31	class QNetworkAccessManager;
32	class QNetworkReply;	32	class QNetworkReply;
33		33
34	class PodcastUrlLoaderReply : public QObject {	34	class PodcastUrlLoaderReply : public QObject {
Lines 101-107 class PodcastUrlLoader : public QObject { Link Here
101	void NextRequest(const QUrl& url, RequestState* state);	101	void NextRequest(const QUrl& url, RequestState* state);
102		102
103	private:	103	private:
104	QNetworkAccessManager* network_;	104	NetworkAccessManager network_;
105	PodcastParser* parser_;	105	PodcastParser* parser_;
106		106
107	QRegExp html_link_re_;	107	QRegExp html_link_re_;

Lines 115-121 bool SeafileService::GetToken(const QString& mail, const QString& password, Link Here

(-)a/src/internet/seafile/seafileservice.cpp (-6 / +6 lines)
115	QNetworkRequest request(url);	115	QNetworkRequest request(url);
116	AddAuthorizationHeader(&request);	116	AddAuthorizationHeader(&request);
117		117
118	QNetworkReply* reply = network_->post(request, url_query.toString().toLatin1());	118	QNetworkReply* reply = network_.post(request, url_query.toString().toLatin1());
119	WaitForSignal(reply, SIGNAL(finished()));	119	WaitForSignal(reply, SIGNAL(finished()));
120		120
121	if (!CheckReply(&reply)) {	121	if (!CheckReply(&reply)) {
Lines 149-155 void SeafileService::GetLibraries() { Link Here
149	QUrl url(server_ + kListReposUrl);	149	QUrl url(server_ + kListReposUrl);
150	QNetworkRequest request(url);	150	QNetworkRequest request(url);
151	AddAuthorizationHeader(&request);	151	AddAuthorizationHeader(&request);
152	QNetworkReply* reply = network_->get(request);	152	QNetworkReply* reply = network_.get(request);
153		153
154	NewClosure(reply, SIGNAL(finished()), this,	154	NewClosure(reply, SIGNAL(finished()), this,
155	SLOT(GetLibrariesFinished(QNetworkReply*)), reply);	155	SLOT(GetLibrariesFinished(QNetworkReply*)), reply);
Lines 299-305 QNetworkReply* SeafileService::PrepareFetchFolderItems(const QString& library, Link Here
299		299
300	QNetworkRequest request(url);	300	QNetworkRequest request(url);
301	AddAuthorizationHeader(&request);	301	AddAuthorizationHeader(&request);
302	QNetworkReply* reply = network_->get(request);	302	QNetworkReply* reply = network_.get(request);
303		303
304	return reply;	304	return reply;
305	}	305	}
Lines 422-428 QNetworkReply* SeafileService::PrepareFetchContentForFile( Link Here
422		422
423	QNetworkRequest request(content_url);	423	QNetworkRequest request(content_url);
424	AddAuthorizationHeader(&request);	424	AddAuthorizationHeader(&request);
425	QNetworkReply* reply = network_->get(request);	425	QNetworkReply* reply = network_.get(request);
426		426
427	return reply;	427	return reply;
428	}	428	}
Lines 488-494 QNetworkReply* SeafileService::PrepareFetchContentUrlForFile( Link Here
488		488
489	QNetworkRequest request(content_url);	489	QNetworkRequest request(content_url);
490	AddAuthorizationHeader(&request);	490	AddAuthorizationHeader(&request);
491	QNetworkReply* reply = network_->get(request);	491	QNetworkReply* reply = network_.get(request);
492		492
493	return reply;	493	return reply;
494	}	494	}
Lines 641-647 bool SeafileService::CheckReply(QNetworkReply** reply, int tries) { Link Here
641	(*reply)->deleteLater();	641	(*reply)->deleteLater();
642		642
643	// We execute the reply again	643	// We execute the reply again
644	reply = network_->get((reply)->request());	644	reply = network_.get((reply)->request());
645	WaitForSignal(*reply, SIGNAL(finished()));	645	WaitForSignal(*reply, SIGNAL(finished()));
646		646
647	return CheckReply(reply, ++tries);	647	return CheckReply(reply, ++tries);

Lines 99-105 void SkydriveService::ConnectFinished(OAuthenticator* oauth) { Link Here

(-)a/src/internet/skydrive/skydriveservice.cpp (-3 / +3 lines)
99	QNetworkRequest request(url);	99	QNetworkRequest request(url);
100	AddAuthorizationHeader(&request);	100	AddAuthorizationHeader(&request);
101		101
102	QNetworkReply* reply = network_->get(request);	102	QNetworkReply* reply = network_.get(request);
103	NewClosure(reply, SIGNAL(finished()), this,	103	NewClosure(reply, SIGNAL(finished()), this,
104	SLOT(FetchUserInfoFinished(QNetworkReply*)), reply);	104	SLOT(FetchUserInfoFinished(QNetworkReply*)), reply);
105	}	105	}
Lines 130-136 void SkydriveService::ListFiles(const QString& folder) { Link Here
130	QNetworkRequest request(url);	130	QNetworkRequest request(url);
131	AddAuthorizationHeader(&request);	131	AddAuthorizationHeader(&request);
132		132
133	QNetworkReply* reply = network_->get(request);	133	QNetworkReply* reply = network_.get(request);
134	NewClosure(reply, SIGNAL(finished()), this,	134	NewClosure(reply, SIGNAL(finished()), this,
135	SLOT(ListFilesFinished(QNetworkReply*)), reply);	135	SLOT(ListFilesFinished(QNetworkReply*)), reply);
136	}	136	}
Lines 173-179 QUrl SkydriveService::GetStreamingUrlFromSongId(const QString& file_id) { Link Here
173	QUrl url(QString(kSkydriveBase) + file_id);	173	QUrl url(QString(kSkydriveBase) + file_id);
174	QNetworkRequest request(url);	174	QNetworkRequest request(url);
175	AddAuthorizationHeader(&request);	175	AddAuthorizationHeader(&request);
176	std::unique_ptr<QNetworkReply> reply(network_->get(request));	176	std::unique_ptr<QNetworkReply> reply(network_.get(request));
177	WaitForSignal(reply.get(), SIGNAL(finished()));	177	WaitForSignal(reply.get(), SIGNAL(finished()));
178		178
179	QJsonObject json_response = QJsonDocument::fromBinaryData(reply.get()->readAll()).object();	179	QJsonObject json_response = QJsonDocument::fromBinaryData(reply.get()->readAll()).object();

Lines 39-48 const int AcoustidClient::kDefaultTimeout = 5000; // msec Link Here

(-)a/src/musicbrainz/acoustidclient.cpp (-5 / +5 lines)
39		39
40	AcoustidClient::AcoustidClient(QObject* parent)	40	AcoustidClient::AcoustidClient(QObject* parent)
41	: QObject(parent),	41	: QObject(parent),
42	network_(new NetworkAccessManager(this)),	42	network_(this),
43	timeouts_(new NetworkTimeouts(kDefaultTimeout, this)) {}	43	timeouts_(kDefaultTimeout, this) {}
44		44
45	void AcoustidClient::SetTimeout(int msec) { timeouts_->SetTimeout(msec); }	45	void AcoustidClient::SetTimeout(int msec) { timeouts_.SetTimeout(msec); }
46		46
47	void AcoustidClient::Start(int id, const QString& fingerprint,	47	void AcoustidClient::Start(int id, const QString& fingerprint,
48	int duration_msec) {	48	int duration_msec) {
Lines 60-71 void AcoustidClient::Start(int id, const QString& fingerprint, Link Here
60	url.setQuery(url_query);	60	url.setQuery(url_query);
61	QNetworkRequest req(url);	61	QNetworkRequest req(url);
62		62
63	QNetworkReply* reply = network_->get(req);	63	QNetworkReply* reply = network_.get(req);
64	NewClosure(reply, SIGNAL(finished()), this,	64	NewClosure(reply, SIGNAL(finished()), this,
65	SLOT(RequestFinished(QNetworkReply*, int)), reply, id);	65	SLOT(RequestFinished(QNetworkReply*, int)), reply, id);
66	requests_[id] = reply;	66	requests_[id] = reply;
67		67
68	timeouts_->AddReply(reply);	68	timeouts_.AddReply(reply);
69	}	69	}
70		70
71	void AcoustidClient::Cancel(int id) { delete requests_.take(id); }	71	void AcoustidClient::Cancel(int id) { delete requests_.take(id); }

Lines 21-29 Link Here

(-)a/src/musicbrainz/acoustidclient.h (-4 / +3 lines)
21	#include <QMap>	21	#include <QMap>
22	#include <QObject>	22	#include <QObject>
23		23
24	class NetworkTimeouts;	24	#include "core/network.h"
25		25
26	class QNetworkAccessManager;
27	class QNetworkReply;	26	class QNetworkReply;
28		27
29	class AcoustidClient : public QObject {	28	class AcoustidClient : public QObject {
Lines 66-73 signals: Link Here
66	static const char* kUrl;	65	static const char* kUrl;
67	static const int kDefaultTimeout;	66	static const int kDefaultTimeout;
68		67
69	QNetworkAccessManager* network_;	68	NetworkAccessManager network_;
70	NetworkTimeouts* timeouts_;	69	NetworkTimeouts timeouts_;
71	QMap<int, QNetworkReply*> requests_;	70	QMap<int, QNetworkReply*> requests_;
72	};	71	};
73		72

Lines 23-29 Link Here

(-)a/src/musicbrainz/musicbrainzclient.h (-2 / +4 lines)
23	#include <QObject>	23	#include <QObject>
24	#include <QXmlStreamReader>	24	#include <QXmlStreamReader>
25		25
26	class NetworkTimeouts;	26	#include "core/network.h"
27		27
28	class QNetworkAccessManager;	28	class QNetworkAccessManager;
29	class QNetworkReply;	29	class QNetworkReply;
Lines 43-48 class MusicBrainzClient : public QObject { Link Here
43	// is not transferred.	43	// is not transferred.
44	MusicBrainzClient(QObject* parent = nullptr,	44	MusicBrainzClient(QObject* parent = nullptr,
45	QNetworkAccessManager* network = nullptr);	45	QNetworkAccessManager* network = nullptr);
		46	~MusicBrainzClient();
46		47
47	struct Result {	48	struct Result {
48	Result() : duration_msec_(0), track_(0), year_(-1) {}	49	Result() : duration_msec_(0), track_(0), year_(-1) {}
Lines 184-191 signals: Link Here
184	static const int kDefaultTimeout;	185	static const int kDefaultTimeout;
185	static const int kMaxRequestPerTrack;	186	static const int kMaxRequestPerTrack;
186		187
		188	bool deleteNetwork;
187	QNetworkAccessManager* network_;	189	QNetworkAccessManager* network_;
188	NetworkTimeouts* timeouts_;	190	NetworkTimeouts timeouts_;
189	QMultiMap<int, QNetworkReply*> requests_;	191	QMultiMap<int, QNetworkReply*> requests_;
190	// Results we received so far, kept here until all the replies are finished	192	// Results we received so far, kept here until all the replies are finished
191	QMap<int, QList<PendingResults>> pending_results_;	193	QMap<int, QList<PendingResults>> pending_results_;

Lines 29-35 Link Here

(-)a/src/songinfo/ultimatelyricsprovider.cpp (-4 / +4 lines)
29	const int UltimateLyricsProvider::kRedirectLimit = 5;	29	const int UltimateLyricsProvider::kRedirectLimit = 5;
30		30
31	UltimateLyricsProvider::UltimateLyricsProvider()	31	UltimateLyricsProvider::UltimateLyricsProvider()
32	: network_(new NetworkAccessManager(this)),	32	: network_(this),
33	relevance_(0),	33	relevance_(0),
34	redirect_count_(0),	34	redirect_count_(0),
35	url_hop_(false) {}	35	url_hop_(false) {}
Lines 54-60 void UltimateLyricsProvider::FetchInfo(int id, const Song& metadata) { Link Here
54	// Fetch the URL, follow redirects	54	// Fetch the URL, follow redirects
55	metadata_ = metadata;	55	metadata_ = metadata;
56	redirect_count_ = 0;	56	redirect_count_ = 0;
57	QNetworkReply* reply = network_->get(QNetworkRequest(url));	57	QNetworkReply* reply = network_.get(QNetworkRequest(url));
58	requests_[reply] = id;	58	requests_[reply] = id;
59	connect(reply, SIGNAL(finished()), SLOT(LyricsFetched()));	59	connect(reply, SIGNAL(finished()), SLOT(LyricsFetched()));
60	}	60	}
Lines 93-99 void UltimateLyricsProvider::LyricsFetched() { Link Here
93	}	93	}
94		94
95	redirect_count_++;	95	redirect_count_++;
96	QNetworkReply* reply = network_->get(QNetworkRequest(target));	96	QNetworkReply* reply = network_.get(QNetworkRequest(target));
97	requests_[reply] = id;	97	requests_[reply] = id;
98	connect(reply, SIGNAL(finished()), SLOT(LyricsFetched()));	98	connect(reply, SIGNAL(finished()), SLOT(LyricsFetched()));
99	return;	99	return;
Lines 128-134 void UltimateLyricsProvider::LyricsFetched() { Link Here
128	url_hop_ = true;	128	url_hop_ = true;
129	QUrl url(content);	129	QUrl url(content);
130	qLog(Debug) << "Next url hop: " << url;	130	qLog(Debug) << "Next url hop: " << url;
131	QNetworkReply* reply = network_->get(QNetworkRequest(url));	131	QNetworkReply* reply = network_.get(QNetworkRequest(url));
132	requests_[reply] = id;	132	requests_[reply] = id;
133	connect(reply, SIGNAL(finished()), SLOT(LyricsFetched()));	133	connect(reply, SIGNAL(finished()), SLOT(LyricsFetched()));
134	return;	134	return;

Lines 21-27 Link Here

(-)a/src/ui/coverfromurldialog.h (-3 / +3 lines)
21	#include <QDialog>	21	#include <QDialog>
22	#include <QImage>	22	#include <QImage>
23		23
24	class NetworkAccessManager;	24	#include "core/network.h"
		25
25	class Song;	26	class Song;
26	class Ui_CoverFromURLDialog;	27	class Ui_CoverFromURLDialog;
27		28
Lines 44-50 class CoverFromURLDialog : public QDialog { Link Here
44	private:	45	private:
45	Ui_CoverFromURLDialog* ui_;	46	Ui_CoverFromURLDialog* ui_;
46		47
47	NetworkAccessManager* network_;	48	NetworkAccessManager network_;
48	QImage last_image_;	49	QImage last_image_;
49	};	50	};
50		51
51	-