26 years ago · 8c5977d18f
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1,55 @@
 # Files generated by Core
 module.generated
 module.sources_protobuf
 **/**/src/generated/g_message_*_messages.cpp
 **/**/src/generated/g_message_*_messages.h
 **/**/src/generated/g_proto_descriptor_*_messages.cpp
 **/**/src/generated/g_proto_descriptor_*_messages.h
 **/**/src/generated/g_proto_*_messages.h
 **/**/src/generated/g_proto_*_messages.cpp
 *_jumbo.cpp
 data/i18ndata/tables/encoding.bin
 data/i18ndata/tables/encodingbin.cpp
 local-tweaks.h
 *.tmp
 /core/

 # Windows-specific
 /debug_unicode/
 /Debug/
 /Instrumented/
 /PGO/
 /release_unicode/
 /Release/
 /vTune/
 *VTune/
 *Debug Unicode DLL/
 *Release Unicode DLL/
 *.vcproj.*.user
 /VS_Output/
 7z.log
 Opera autoupdate.exe
 Opera installer.exe
 Opera.7z
 desktop.ini

 # Mac-specific
 /build/
 /output/

 # UNIX-specific
 /build/
 /run/
 /packages/
 /build.log
 /build.log.*
 *~
 .#*

 # Other
 /adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/curl
 /*.conf.py
 *.py[oc]
 *Tagging/
 /#*#
 .DS_Store
--- a/README.md
+++ b/README.md
@@ -1 +1,5 @@
 # browser
 # Presto Web rendering engine: Opera 12.15

 This repository contains the Presto rendering engine, used up to Opera 12.

 .-Peace out
--- a/adjunct/autoupdate/additionchecker.cpp
+++ b/adjunct/autoupdate/additionchecker.cpp
@@ -0,0 +1,530 @@
 /* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
 *
 * Copyright (C) 1995-2012 Opera Software ASA.  All rights reserved.
 *
 * This file is part of the Opera web browser.	It may not be distributed
 * under any circumstances.
 *
 * @author Michal Zajaczkowski
 */

 #include "core/pch.h"

 #ifdef AUTO_UPDATE_SUPPORT
 #include "adjunct/autoupdate/additionchecker.h"
 #include "adjunct/autoupdate/additioncheckerlistener.h"
 #include "adjunct/autoupdate/autoupdateserverurl.h"
 #include "adjunct/quick/managers/AutoUpdateManager.h"

 /**
  * The list of updatable resource types that can be resolved by the addition checker.
  * No other type of resource will be possible to resolve this way.
  */
 UpdatableResource::UpdatableResourceType AdditionChecker::KNOWN_TYPES[] = 
 	{
 		UpdatableResource::RTPlugin,
 		UpdatableResource::RTDictionary
 	};

 /**
 * The number of seconds that will pass between resolving a new addition has been requested and the actual HTTP request.
 * The lower this is, the faster the resolve will happen, the higher it is, the less requests will be made since more 
 * items will have the chance to get scheduled for a single request.
 * The plugin install manager might request a couple of mimetypes for a single Web page during the page load, and we'd 
 * rather send them out with a single HTTP request to the autoupdate server.
 */
 const unsigned int AdditionChecker::RESOLVE_TIMER_KICK_NOW_PERIOD_SEC = 2;

 /**
 * The number of seconds that will pass between a failed request to the autoupdate server and a retry attempt. Note that
 * requesting any new addition check during the retry time will cause the retry to happen sooner, with the new addition
 * resolve attempt.
 */
 const unsigned int AdditionChecker::RESOLVE_TIMER_KICK_DELAYED_PERDIOD_SEC = 10;

 /**
 * The maximum number of resolve attempts per item. If the item could not be resolved with this many requests to the autoupdate
 * server, it is broadcasted as failing to resolve.
 */
 const unsigned int AdditionChecker::RESOLVE_MAX_RETRY_COUNT_PER_ITEM = 5;

 AdditionChecker::AdditionChecker():
 	m_resolve_timer(NULL),
 	m_autoupdate_server_url(NULL),
 	m_autoupdate_xml(NULL)
 {
 }

 AdditionChecker::~AdditionChecker()
 {
 	OP_DELETE(m_autoupdate_server_url);
 	OP_DELETE(m_autoupdate_xml);

 	if (m_resolve_timer)
 		m_resolve_timer->SetTimerListener(NULL);

 	OP_DELETE(m_resolve_timer);

 	// Delete all items that are still not resolved
 	m_items.DeleteAll();

 	// Stop and *delete* all downloaders that might happen to be still alive
 	for (UINT32 i=0; i<m_xml_downloaders.GetCount(); i++)
 	{
 		StatusXMLDownloader* downloader = m_xml_downloaders.Get(i);
 		OP_ASSERT(downloader);
 		OpStatus::Ignore(downloader->StopRequest());
 	}
 	m_xml_downloaders.DeleteAll();
 }

 OP_STATUS AdditionChecker::Init()
 {
 	OpAutoPtr<OpTimer> resolve_timer_guard;
 	OpAutoPtr<AutoUpdateXML> autoupdate_xml_guard;
 	OpAutoPtr<AutoUpdateServerURL> autoupdate_server_url_guard;

 	m_resolve_timer = OP_NEW(OpTimer, ());
 	RETURN_OOM_IF_NULL(m_resolve_timer);
 	resolve_timer_guard = m_resolve_timer;
 	m_resolve_timer->SetTimerListener(this);

 	m_autoupdate_xml = OP_NEW(AutoUpdateXML, ());
 	RETURN_OOM_IF_NULL(m_autoupdate_xml);
 	autoupdate_xml_guard = m_autoupdate_xml;
 	RETURN_IF_ERROR(m_autoupdate_xml->Init());

 	m_autoupdate_server_url = OP_NEW(AutoUpdateServerURL, ());
 	RETURN_OOM_IF_NULL(m_autoupdate_server_url);
 	autoupdate_server_url_guard = m_autoupdate_server_url;
 	RETURN_IF_ERROR(m_autoupdate_server_url->Init());

 	resolve_timer_guard.release();
 	autoupdate_xml_guard.release();
 	autoupdate_server_url_guard.release();

 	return OpStatus::OK;
 }

 OP_STATUS AdditionChecker::AddListener(AdditionCheckerListener* listener)
 {
 	return m_listeners.Add(listener);
 }

 OP_STATUS AdditionChecker::RemoveListener(AdditionCheckerListener* listener)
 {
 	return m_listeners.Remove(listener);
 }

 OP_STATUS AdditionChecker::CheckForAddition(UpdatableResource::UpdatableResourceType type, const OpStringC& key)
 {
 	// Did you call Init()?
 	OP_ASSERT(m_resolve_timer);

 	// Only allow the known types. See AdditionChecker::KNOWN_TYPES[]
 	if (!IsKnownType(type))
 	{
 		OP_ASSERT(!"Uknown resource type passed to addition checker!");
 		return OpStatus::ERR;
 	}

 	// Only allow new items, don't cache same items twice.
 	if (NULL == GetItem(type, key))
 	{
 		// Haven't seen this item before, save it among m_items as pending a resolve attempt.
 		OpAutoPtr<AdditionCheckerItem> item(OP_NEW(AdditionCheckerItem, ()));
 		RETURN_OOM_IF_NULL(item.get());
 		RETURN_IF_ERROR(item->SetKey(key));
 		item->SetType(type);
 		RETURN_IF_ERROR(m_items.Add(item.get()));
 		item.release();
 	}

 	/* No matter if the item was known before or not, reset the resolve timer in order to
 	 * shorten the retry time in case we're in the retry period at the moment and still
 	 * allow to cache more items before a request is made if this is a new item.
 	 */ 
 	KickResolveTimer(KickNow);

 	return OpStatus::OK;
 }

 AdditionCheckerItem* AdditionChecker::GetItem(UpdatableResource::UpdatableResourceType type, const OpStringC& key)
 {
 	OP_ASSERT(key.HasContent());
 	// Find an item with the given type and key, there should be only one, but we don't verify that here
 	AdditionCheckerItem* item = NULL;
 	for (UINT32 i=0; i<m_items.GetCount(); i++)
 	{
 		item = m_items.Get(i);
 		OP_ASSERT(item);
 		if (item->IsType(type) && item->IsKey(key))
 			return item;
 	}
 	return NULL;
 }

 OP_STATUS AdditionChecker::GetItemsForDownloader(OpVector<AdditionCheckerItem>& items, StatusXMLDownloader* downloader)
 {
 	// Gather all items that are supposed to be resolved by the given StatusXMLDownloader.
 	for (UINT32 i=0; i<m_items.GetCount(); i++)
 	{
 		AdditionCheckerItem* item = m_items.Get(i);
 		OP_ASSERT(item);
 		if (item->IsXMLDownloader(downloader))
 			RETURN_IF_ERROR(items.Add(item));
 	}
 	return OpStatus::OK;
 }

 OP_STATUS AdditionChecker::GetItemsForDownloaderAndType(OpVector<AdditionCheckerItem>& items, StatusXMLDownloader* downloader, UpdatableResource::UpdatableResourceType type)
 {
 	// Gather all items that are supposed to be resolved by the given StatusXMLDownloader.
 	for (UINT32 i=0; i<m_items.GetCount(); i++)
 	{
 		AdditionCheckerItem* item = m_items.Get(i);
 		OP_ASSERT(item);
 		if (item->IsXMLDownloader(downloader) && item->IsType(type))
 			RETURN_IF_ERROR(items.Add(item));
 	}
 	return OpStatus::OK;

 }

 void AdditionChecker::OnTimeOut(OpTimer* timer)
 {
 	OP_ASSERT(m_resolve_timer);
 	if (timer == m_resolve_timer)
 	{
 		if (OpStatus::IsError(OnResolveTimeOut()))
 		{
 			// Something went terribly wrong. Perhaps things will get better next time an addition check is requested,
 			// however this should not happen.
 			OP_ASSERT(!"Shouldn't happen");
 		}
 	}
 	else
 		OP_ASSERT(!"Unknown timer");
 }

 OP_STATUS AdditionChecker::OnResolveTimeOut()
 {
 	OP_ASSERT(m_resolve_timer);
 	OP_ASSERT(m_autoupdate_xml);
 	OP_ASSERT(m_autoupdate_server_url);
 	// The resolve timer fired. We want to send a request to the autoupdate server asking about all additions that are still not resolved
 	// at this moment.
 	// Since the autoupdate server requires a different autoupdate check level for every different addition type and since we really don't
 	// want to change that, we cannot mix different addition types with one request to the server.

 	// Go through all the known types
 	for (UINT32 i=0; i<GetKnownTypesCount(); i++)
 	{
 		// The type that we're currently processing
 		UpdatableResource::UpdatableResourceType current_type = KNOWN_TYPES[i];
 		OP_ASSERT(current_type);

 		// Gather a list of all addition items of the current type that are still not resolved in this vector
 		OpVector<AdditionCheckerItem> items;
 		// Get a list of all items of the current type that have a NULL downloader, meaning that they are not 
 		// waiting for a callback from a downloader.
 		RETURN_IF_ERROR(GetItemsForDownloaderAndType(items, NULL, current_type));

 		if (items.GetCount() > 0)
 		{
 			// There is only one AutoUpdateXML, so we need to prepare it for a new request
 			m_autoupdate_xml->ClearRequestItems();

 			for (UINT32 i=0; i<items.GetCount(); i++)
 			{
 				AdditionCheckerItem* item = items.Get(i);
 				OP_ASSERT(item);
 				// Add the item to the AutoUpdateXML, this is needed to generate the proper request XML with all the items
 				// we want to resolve.
 				RETURN_IF_ERROR(m_autoupdate_xml->AddRequestItem(item));
 			}

 			// Get the current autoupdate server address. It is possible to have multiple addresses in the Autoupdate Server
 			// preference, these will be cycled through in case of error while getting the response XML.
 			OpString autoupdate_server_url_string;
 			RETURN_IF_ERROR(m_autoupdate_server_url->GetCurrentURL(autoupdate_server_url_string));

 			// Create a new StatusXMLDownloader that will be responsible for resolving this particular list of items
 			OpAutoPtr<StatusXMLDownloader> current_downloader(OP_NEW(StatusXMLDownloader, ()));
 			RETURN_OOM_IF_NULL(current_downloader.get());
 			// The StatusXMLDownloader class saves the response XML to the filesystem in order to parse it. This is needed to
 			// be able to reparse the XML in case the browser has crashed during autoupdate check, since we want to try hard
 			// to limit the request count made to the autoupdate server.
 			// The check type for the downloader determines if the response XML is saved in the autoupdate_response.xml file
 			// or a temporary file with a temporary name that will be lost right after the check is done.
 			RETURN_IF_ERROR(current_downloader->Init(StatusXMLDownloader::CheckTypeOther, this));

 			// Get the autoupdate XML request string basing on the items that we want to resolve
 			OpString8 xml_string;
 			RETURN_IF_ERROR(m_autoupdate_xml->GetRequestXML(xml_string));

 			// Save the StatusXMLDownloader to be able to recoginze it later
 			RETURN_IF_ERROR(m_xml_downloaders.Add(current_downloader.get()));

 			// Start the XML request, we'll get a callback via the StatusXMLDownloaderListener interface once the request
 			// is complete
 			RETURN_IF_ERROR(current_downloader->StartXMLRequest(autoupdate_server_url_string, xml_string));

 			// Since everything went fine, we want to set the StatusXMLDownloader pointer for all items that were requested
 			// with the above call.
 			for (UINT32 i=0; i<items.GetCount(); i++)
 			{
 				AdditionCheckerItem* item = items.Get(i);
 				OP_ASSERT(item);
 				item->SetXMLDownloader(current_downloader.get());
 			}

 			// Forget about the downloader now, we hold it in the m_xml_downloaders vector
 			current_downloader.release();
 		}
 		else
 		{
 			// No items of this type found currently, we'll pick up the remaining items with the next pass.
 		}
 	}
 	return OpStatus::OK;
 }

 void AdditionChecker::StatusXMLDownloaded(StatusXMLDownloader* downloader)
 {
 	OP_ASSERT(downloader);
 	// Check if we have spawned the downloader that is calling us back
 	OP_ASSERT(m_xml_downloaders.Find(downloader) != -1);

 	// Get all the items that are currently waiting to be resolved by the downloader that is calling us back
 	OpVector<AdditionCheckerItem> items;
 	// We can't return an error from this method. The only reason for GetItemsForDownloader() to fail
 	// seems to be an OOM. Let's try to resume operation with whatever items there are, we need to get
 	// to deleting the downloader at the end of this method anyway.
 	OpStatus::Ignore(GetItemsForDownloader(items, downloader));

 	// The StatusXMLDownloader gives us a list of resources that it got in response to the HTTP request that was sent out.
 	// First, we check all the items that match both among the items waiting to be resolved and those sent by the downloader.
 	for (UINT32 i=0; i<items.GetCount(); i++)
 	{
 		AdditionCheckerItem* item = items.Get(i);
 		OP_ASSERT(item);

 		UpdatableResource* resource = downloader->GetFirstResource(); 

 		// Go through all the resources that are currently left in the downloader
 		while (resource)
 		{
 			UpdatableResource::UpdatableResourceType resource_type = resource->GetType();
 			URAttr resource_key = resource->GetResourceKey();

 			// You haven't implemented UpdatableResource::GetResourceKey() for your resource type if this assert triggers.
 			OP_ASSERT(URA_LAST != resource_key);

 			OpString key_value;

 			// If this resource is our addition...
 			if (OpStatus::IsSuccess(resource->GetAttrValue(resource_key, key_value)) && item->IsType(resource_type) && item->IsKey(key_value))
 			{
 				// Notify that it is resolved and forget about it
 				NotifyAdditionResolved(resource_type, key_value, resource);
 				RETURN_VOID_IF_ERROR(downloader->RemoveResource(resource));
 				// Note that we have invalid items in the items vector now, but we don't go back over it anyway
 				RETURN_VOID_IF_ERROR(m_items.Delete(item));
 				break;
 			}
 			resource = downloader->GetNextResource();
 		}
 	}

 	// Go through all the items that we should have gotten with this StatusXMLDownloader but we didn't
 	items.Clear();
 	// We can't return an error from this method. The only reason for GetItemsForDownloader() to fail
 	// seems to be an OOM. Let's try to resume operation with whatever items there are, we need to get
 	// to deleting the downloader at the end of this method anyway.
 	OpStatus::Ignore(GetItemsForDownloader(items, downloader));

 	// This shouldn't really happen since we should always get a response about an item if we ask about it
 	// but the autoupdate server has its ways.
 	for (UINT32 i=0; i<items.GetCount(); i++)
 	{
 		AdditionCheckerItem* item = items.Get(i);
 		OP_ASSERT(item);
 		OpString key;
 		if (OpStatus::IsSuccess(item->GetKey(key)))
 		{
 			// We can only notify if we can know the key.
 			NotifyAdditionResolveFailed(item->GetType(), key);
 		}

 		OpStatus::Ignore(m_items.Delete(item));
 	}

 	// Iterate over all the resources that the downloader sent us but that we have never asked for.
 	UpdatableResource* resource = downloader->GetFirstResource(); 
 	while (resource)
 	{
 		// If this is a setting then we'll handle it
 		if (resource->GetType() == UpdatableResource::RTSetting)
 		{
 			UpdatableSetting* setting = static_cast<UpdatableSetting*>(resource);
 			if (!(setting->CheckResource() && OpStatus::IsSuccess(setting->UpdateResource())))
 				OP_ASSERT(!"Could not update setting resource!");
 		}
 		else
 		{
 			// But if it's anything else then we're really confused
 			OP_ASSERT(!"Unexpected resource got from the autoupdate server!");
 		}
 		OpStatus::Ignore(downloader->RemoveResource(resource));
 		resource = downloader->GetNextResource();
 	}

 	// Delete the downloader finally.
 	OpStatus::Ignore(m_xml_downloaders.Delete(downloader));
 }

 void AdditionChecker::StatusXMLDownloadFailed(StatusXMLDownloader* downloader, StatusXMLDownloader::DownloadStatus status)
 {
 	OP_ASSERT(downloader);
 	// Check if we know the downloader
 	OP_ASSERT(m_xml_downloaders.Find(downloader) != -1);

 	// Try to increment the server URL, i.e. use a different one next time. This will most likely fail since we use one server anyway.
 	OpStatus::Ignore(m_autoupdate_server_url->IncrementURLNo(AutoUpdateServerURL::Wrap));

 	// Get the list of all the items that should be resolved by this downloader
 	OpVector<AdditionCheckerItem> items;
 	// We can't return an error from this method. The only reason for GetItemsForDownloader() to fail
 	// seems to be an OOM. Let's try to resume operation with whatever items there are, we need to get
 	// to deleting the downloader at the end of this method anyway.
 	OpStatus::Ignore(GetItemsForDownloader(items, downloader));

 	for (UINT32 i=0; i<items.GetCount(); i++)
 	{
 		AdditionCheckerItem* item = items.Get(i);
 		OP_ASSERT(item);
 		// Increment the retry timer
 		item->IncRetryCounter();
 		// Set the downloader to NULL in order to pick this item up with the next resolve attempt.
 		item->SetXMLDownloader(NULL);

 		// However in case the item has reached the maximum retry count, notify it has failed to be resolved and drop it without a further retry
 		if (item->GetRetryCounterValue() >= RESOLVE_MAX_RETRY_COUNT_PER_ITEM)
 		{
 			OpString item_key;
 			UpdatableResource::UpdatableResourceType item_type = item->GetType();
 			if (OpStatus::IsSuccess(item->GetKey(item_key)))
 				NotifyAdditionResolveFailed(item_type, item_key);

 			OpStatus::Ignore(m_items.Delete(item));
 		}
 	}

 	// If there still are some items that should be retried, schedule a retry attempt
 	if (items.GetCount() > 0)
 		KickResolveTimer(KickDelayed);

 	OpStatus::Ignore(m_xml_downloaders.Delete(downloader));
 }

 void AdditionChecker::NotifyAdditionResolved(UpdatableResource::UpdatableResourceType type, const OpStringC& key, UpdatableResource* resource)
 {
 	for (OpListenersIterator iterator(m_listeners); m_listeners.HasNext(iterator);)
 		m_listeners.GetNext(iterator)->OnAdditionResolved(type, key, resource);
 }

 void AdditionChecker::NotifyAdditionResolveFailed(UpdatableResource::UpdatableResourceType type, const OpStringC& key)
 {
 	for (OpListenersIterator iterator(m_listeners); m_listeners.HasNext(iterator);)
 		m_listeners.GetNext(iterator)->OnAdditionResolveFailed(type, key);
 }

 UINT32 AdditionChecker::GetKnownTypesCount()
 {
 	size_t item_size = sizeof(UpdatableResource::UpdatableResourceType);
 	size_t full_size = sizeof(KNOWN_TYPES);
 	return full_size / item_size;
 }

 bool AdditionChecker::IsKnownType(UpdatableResource::UpdatableResourceType type)
 {
 	UINT32 count = GetKnownTypesCount();
 	for (UINT32 i=0; i<count; i++)
 	{
 		if (KNOWN_TYPES[i] == type)
 			return true;
 	}
 	return false;
 }

 void AdditionChecker::KickResolveTimer(KickType type)
 {
 	OP_ASSERT(m_resolve_timer);
 	if (KickNow == type)
 		m_resolve_timer->Start(RESOLVE_TIMER_KICK_NOW_PERIOD_SEC * 1000);
 	else
 		m_resolve_timer->Start(RESOLVE_TIMER_KICK_DELAYED_PERDIOD_SEC * 1000);
 }

 /***********************
 * AdditionCheckerItem *
 ***********************/

 AdditionCheckerItem::AdditionCheckerItem():
 	m_status_xml_downloader(NULL),
 	m_type(UpdatableResource::RTEmpty),
 	m_retry_counter(0)
 {
 }

 AdditionCheckerItem::~AdditionCheckerItem()
 {
 }

 OP_STATUS AdditionCheckerItem::SetKey(const OpStringC& key)
 {
 	return m_key.Set(key);
 }

 void AdditionCheckerItem::SetType(UpdatableResource::UpdatableResourceType type)
 {
 	m_type = type;
 }

 OP_STATUS AdditionCheckerItem::GetKey(OpString& key)
 {
 	return key.Set(m_key);
 }

 UpdatableResource::UpdatableResourceType AdditionCheckerItem::GetType()
 {
 	return m_type;
 }

 bool AdditionCheckerItem::IsType(UpdatableResource::UpdatableResourceType type)
 {
 	return m_type == type;
 }

 bool AdditionCheckerItem::IsKey(const OpStringC& key)
 {
 	return m_key.CompareI(key) == 0;
 }

 bool AdditionCheckerItem::IsXMLDownloader(const StatusXMLDownloader* downloader)
 {
 	return m_status_xml_downloader == downloader;
 }

 void AdditionCheckerItem::SetXMLDownloader(const StatusXMLDownloader* downloader)
 {
 	m_status_xml_downloader = downloader;
 }

 const StatusXMLDownloader* AdditionCheckerItem::GetXMLDownloader()
 {
 	return m_status_xml_downloader;
 }

 #endif // AUTO_UPDATE_SUPPORT
--- a/adjunct/autoupdate/additionchecker.h
+++ b/adjunct/autoupdate/additionchecker.h
@@ -0,0 +1,374 @@
 /* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
 *
 * Copyright (C) 1995-2011 Opera Software AS.  All rights reserved.
 *
 * This file is part of the Opera web browser.	It may not be distributed
 * under any circumstances.
 *
 * @author Michal Zajaczkowski
 */

 #ifdef AUTO_UPDATE_SUPPORT

 #ifndef AUTOUPDATE_ADDITION_CHECKER_H
 #define AUTOUPDATE_ADDITION_CHECKER_H

 #include "modules/util/adt/oplisteners.h"
 #include "modules/hardcore/timer/optimer.h"
 #include "adjunct/autoupdate/autoupdatexml.h"
 #include "adjunct/autoupdate/autoupdateserverurl.h"
 #include "adjunct/autoupdate/statusxmldownloader.h"

 class AutoUpdateXML;
 class AutoUpdateManager;
 class AutoUpdateServerURL;
 class AdditionCheckerListener;

 /**
 * AdditionCheckerItem represents a single addition item that is being resolved by the addition checker.
 * Each item has a type (i.e. UpdatableResource::ResourceTypePlugin), a key (i.e. the mimetype of the plugin) and a 
 * StatusXMLDownloader* value. 
 * If the item is not waiting to be resolved by any StatusXMLDownloader, then it has the downloader value set to NULL.
 * Otherwise the downloader value points to the StatusXMLDownloader object that should send back information about this
 * particular item.
 */
 class AdditionCheckerItem
 {
 public:
 	AdditionCheckerItem();
 	~AdditionCheckerItem();

 	/**
 	 * Sets the value of the key of the addition item (i.e. the plugin mime-type)
 	 *
 	 * @param key - the new value of the key
 	 *
 	 * @returns - OpStatus:OK if setting the key value succeeds, ERR otherwise
 	 */
 	OP_STATUS SetKey(const OpStringC& key);

 	/**
 	 * Sets the type of the addition item (i.e. UpdatableResource::ResourceTypePlugin)
 	 *
 	 * @param type - the new type to set
 	 *
 	 * @returns nothing
 	 */
 	void SetType(UpdatableResource::UpdatableResourceType type);

 	/**
 	 * Assings a StatusXMLDownloader to the addition item, designating that item is pending an autoupdate response from the
 	 * particular downloader. If this value is NULL, then the item is pending to be resolved.
 	 *
 	 * @param downloader - the new StatusXMLDownloader* value
 	 */
 	void SetXMLDownloader(const StatusXMLDownloader* downloader);

 	/**
 	 * Get the key of the item (i.e. the mime-type of a plugin)
 	 *
 	 * @param key - a reference to an OpString that will get the key value in case of success
 	 *
 	 * @returns - OpStatus::OK in case the value was set OK, ERR otherwise
 	 */
 	OP_STATUS GetKey(OpString& key);

 	/**
 	 * Get the type of the item, i.e. UpdatableResource::ResourceTypePlugin
 	 *
 	 * @returns - the type of the item
 	 */
 	UpdatableResource::UpdatableResourceType GetType();

 	/**
 	 * Get the StatusXMLDownloader* value assinged to the item, see SetXMLDownloader()
 	 *
 	 * @returns - the StatusXMLDownloader* value
 	 */
 	const StatusXMLDownloader* GetXMLDownloader();

 	/**
 	 * Check if this item is of the given type
 	 *
 	 * @param type - the type that we want to verify against the type of this item
 	 *
 	 * @returns - TRUE in case the type of this item matches the given type, FALSE otherwise
 	 */
 	bool IsType(UpdatableResource::UpdatableResourceType type);

 	/**
 	 * Check if this item has the given key value
 	 *
 	 * @param key - the key value that we want to check against the key of this item
 	 *
 	 * @returns TRUE in case the keys match, FALSE otherwise
 	 */
 	bool IsKey(const OpStringC& key);

 	/**
 	 * Check if the value of the StatusXMLDownloader pointer assigned to this item matches the given value
 	 *
 	 * @param downloader - the StatusXMLDownloader pointer value that is to be checked against the value stored with this item
 	 *
 	 * @returns - TRUE in case the pointers match, FALSE otherwise
 	 */
 	bool IsXMLDownloader(const StatusXMLDownloader* downloader);

 	/**
 	 * Increment the resolve retry counter for this item. This method does not check if the pointer exceeded the maximum retry count.
 	 */ 
 	void	IncRetryCounter() { m_retry_counter++; }

 	/**
 	 * Get the retry counter value to compare against the maximum retry count in the calling code.
 	 *
 	 * @returns - the current retry count for the given item
 	 */
 	unsigned int GetRetryCounterValue() { return m_retry_counter; }

 private:
 	/**
 	 * The value of the key for this item. The key is an unique identifier among all items of the same type, i.e. a mime-type for a plugin.
 	 */
 	OpString m_key;

 	/**
 	 * The value of the StatusXMLDownloader pointer assigned to this item. This is NULL in case this item is pending resolving and it points
 	 * to a downloader that should resolve this item in case the item has been requested to resolve.
 	 */
 	const StatusXMLDownloader* m_status_xml_downloader;

 	/**
 	 * Type of the addition represented by this item, i.e. UpdatableResource::ResourceTypePlugin.
 	 */
 	UpdatableResource::UpdatableResourceType m_type;

 	/**
 	 * The resolve retry counter that counts how many times a request about the given item has been sent to the autoupdate server.
 	 * Used to have a resolve retry mechanism that will give up after RESOLVE_MAX_RETRY_COUNT_PER_ITEM attempts.
 	 */
 	unsigned int m_retry_counter;
 };

 /**
 * The autoupdate server currently serves two quite different purposes:
 * 1. Keeping the browser up-to-date with periodic automatic checks and manual checks;
 * 2. Making it possible to discover and download "additions" via the autoupdate server.
 *
 * An addition is any additional installable resource that might be needed during the browser run, currently
 * the only supported addition types are plugins and dictionaries, both installable on user demand. If the user
 * visits a page that requires a given plugin, the plugin availablity is checked against the autoupdate server with
 * the additions mechanisms.
 *
 * If you want to add a new type of resource that you want to resolve via the autoupdate server, you need to:
 * 1. Add a new resource type (see updatableresource.h, updatablefile.h);
 * 2. Add the new resource to the KNOWN_TYPES[] array;
 * 3. Agree with the core services team that the autoupdate server will support the new resource, agree a new update level for the new resource type! See 
 *    AutoUpdateXML::AutoUpdateLevel.
 * 4. Make sure the UpdatableResourceFactory is able to recognize all the XML elements used to describe the new resource
 *    type;
 * 5. Choose a key for the new resource. This is the value that is supposed to be unique across all resources of the same type, 
 *    i.e. the mimetype for a plugin or the language for a dictionary, make sure you implement the key by implementing the 
 *    UpdatableResource::GetResourceKey() method.
 * 6. Make sure AutoUpdateXML can recognize the new resource type, choose a new update check level and generate a proper XML for the new item type.
 * 7. You should get asserts if you forget about any of the above;
 *
 * In order to resolve a resource:
 * 1. Make your class inherit from the AdditionCheckerListener class, implement its methods;
 * 2. Register yourself as a listener with something like g_autoupdate_manager->AddListener(this);
 * 3. Call g_autoupdate_manager->CheckForAddition() to check the availability of the addition and wait for a callback via the
 *    AdditionCheckerListener interface;
 * 4. Carry on.
 *
 * The addition checker will try to repeat failed requests to the autoupdate server on its own, so you can consider that when it
 * fails to resolve the addition, it fails for good.
 * The addition checker may make a couple of HTTP requests to the autoupdate server in parallel in order to speed up things.
 * The addition checker will send a cummulative requst about all additions of a given type that are not resolved at the moment
 * of seding the request. 
 *
 * The AdditionChecker class is meant to be used by the AutoUpdateManager only. The AutoUpdateManager has all the interfaces
 * required to use the addition resolving functionality.
 *
 */
 class AdditionChecker:
 	public OpTimerListener,
 	public StatusXMLDownloaderListener
 {
 	friend class AutoUpdateManager;
 public:
 	AdditionChecker();
 	virtual ~AdditionChecker();

 protected:
 	/**
 	 * The list of types that the AdditionChecker is be able to resolve.
 	 */
 	static UpdatableResource::UpdatableResourceType KNOWN_TYPES[];
 	/**
 	 * The resolve timer timeout period for the KickNow kick type.
 	 */
 	static const unsigned int RESOLVE_TIMER_KICK_NOW_PERIOD_SEC;
 	/**
 	 * The resolve timer timeout period for the KickDelayed kick type.
 	 */
 	static const unsigned int RESOLVE_TIMER_KICK_DELAYED_PERDIOD_SEC;
 	/**
 	 * The maximum retry count per a queued addition item, if the addition is not resolved after this many tries, it's 
 	 * broadcasted as failed.
 	 */
 	static const unsigned int RESOLVE_MAX_RETRY_COUNT_PER_ITEM;

 	enum KickType
 	{
 		/**
 		 * Start the resolve timer using the RESOLVE_TIMER_KICK_DELAYED_PERDIOD_SEC period
 		 */
 		KickDelayed,
 		/**
 		 * Start the resolve timer using the RESOLVE_TIMER_KICK_NOW_PERIOD_SEC period
 		 */
 		KickNow
 	};

 	/**
 	 * Initializes the object, needs to be called once before any operations are made on the AdditionChecker.
 	 *
 	 * @returns - OpStatus::OK if initialization went OK, ERR otherwise. The object can't be used until Init() returns OpStatus::OK.
 	 */
 	OP_STATUS Init();

 	/**
 	 * OpTimerListener implementation.
 	 */
 	virtual void OnTimeOut(OpTimer* timer);

 	/**
 	 * Handler for resolve timer. Will send out autoupdate XML requests for items awaiting resolving.
 	 *
 	 * @returns - OpStatus::OK on success, ERR otherwise.
 	 */
 	OP_STATUS OnResolveTimeOut();

 	/**
 	 * Implementation of the StatusXMLDownloaderListener interface.
 	 */
 	virtual void StatusXMLDownloaded(StatusXMLDownloader* downloader);
 	virtual void StatusXMLDownloadFailed(StatusXMLDownloader* downloader, StatusXMLDownloader::DownloadStatus status);

 	/**
 	 * Register a listener with the addition resolver. You don't want to do that with your classes, use g_autoupdate_manager->AddListener().
 	 *
 	 * @param listener - a pointer to a class inheriting from the AdditionCheckerListener interface.
 	 *
 	 * @returns - OpStatus::OK if adding the listener succeeded, OpStatus::ERR otherwise.
 	 */
 	OP_STATUS AddListener(AdditionCheckerListener* listener);

 	/**
 	 * Unregister a listener with the addition resolver. You don't want to do that with your classes, use g_autoupdate_manager->RemoveListener().
 	 *
 	 * @param listener - a pointer to a class inheriting from the AdditionCheckerListener interface.
 	 *
 	 * @returns - OpStatus::OK if removing the listener succeeded, OpStatus::ERR otherwise.
 	 */
 	OP_STATUS RemoveListener(AdditionCheckerListener* listener);

 	/**
 	 * Try to resolve an addition of the given type and the given key against the autoupdate server. You don't want to use this, use 
 	 * g_autoupdate_manager->CheckForAddition() instead.
 	 * Before you call this method, be sure to register as a listener to AdditionChecker.
 	 * After a call to this method, wait for a callback via the AdditionCheckerListener interface.
 	 * Note that the actual XML request will be made later on, after the resolve timer fires.
 	 *
 	 * @param type - the type of the addition to be resolved.
 	 * @param key - the key of the addition to be resolved.
 	 *
 	 * @returns - OpStatus::OK if queing the addition check was OK, ERR otherwise.
 	 */
 	OP_STATUS CheckForAddition(UpdatableResource::UpdatableResourceType type, const OpStringC& key);

 	/**
 	 * Starts the resolve timer with the timeout period determined by the parameter given.
 	 *
 	 * @param type - determines the timeout period, see KickType definition.
 	 */
 	void KickResolveTimer(KickType type);

 	/**
 	 * Notifies all the registered listeners about an addition being resolved or failed to resolve.
 	 */
 	void NotifyAdditionResolved(UpdatableResource::UpdatableResourceType type, const OpStringC& key, UpdatableResource* resource);
 	void NotifyAdditionResolveFailed(UpdatableResource::UpdatableResourceType type, const OpStringC& key);

 	/**
 	 * Checks if a resource with the given type can be resolved as an addition.
 	 */
 	bool IsKnownType(UpdatableResource::UpdatableResourceType type);

 	/**
 	 * Get the total number of the types recognized as additions. Returns the number of items in the KNOWN_TYPES[] array.
 	 */
 	UINT32 GetKnownTypesCount();

 	/**
 	 * Searches the m_items vector for an item with the given type and key.
 	 * The m_items vector should never contain more than one item with the same type AND key, i.e. we should never have queued
 	 * more than one plugin with the same mime-type.
 	 * This method doesn't check that condition, it relies on CheckForAddition() making the proper checks.
 	 *
 	 * @param type - addition type
 	 * @param key - addition key
 	 *
 	 * @returns - a pointer to the addition item found, if one, NULL otherwise.
 	 */
 	AdditionCheckerItem* GetItem(UpdatableResource::UpdatableResourceType type, const OpStringC& key);

 	/**
 	 * Searches the m_items vector for all items that have the given StatusXMLDownloader assigned to them.
 	 *
 	 * @param items - a reference to a vector that will contain the items found.
 	 * @param downloader - a pointer to the StatusXMLDownloader that we're looking for, may be NULL.
 	 *
 	 * @returns - OpStatus::OK if everything went fine, ERR otherwise.
 	 */
 	OP_STATUS GetItemsForDownloader(OpVector<AdditionCheckerItem>& items, StatusXMLDownloader* downloader);

 	/**
 	 * Searches the m_items vector for all items that have the given StatusXMLDownloader assigned to them AND that are of the given type.
 	 *
 	 * @param items - a reference to a vector that will contain the items found.
 	 * @param downloader - a pointer to the StatusXMLDownloader that we're looking for, may be NULL.
 	 * @param type - the type of the items that we care about.
 	 *
 	 * @returns - OpStatus::OK if everything went fine, ERR otherwise.
 	 */
 	OP_STATUS GetItemsForDownloaderAndType(OpVector<AdditionCheckerItem>& items, StatusXMLDownloader* downloader, UpdatableResource::UpdatableResourceType type);

 	/**
 	 * Hold a list of StatusXMLDownloader objects that were created when making the XML requests.
 	 * A downloader is destroyed and removed after a callback is returned from it via the StatusXMLDownloaderListener interface.
 	 * Additionally, if any downloaders still exist while the AdditionChecker is destroyed, they are stopped and destroyed as well.
 	 */
 	OpVector<StatusXMLDownloader> m_xml_downloaders;

 	/**
 	 * The resolve timer.
 	 */
 	OpTimer* m_resolve_timer;

 	/**
 	 * The list of registered listeners.
 	 */
 	OpListeners<AdditionCheckerListener> m_listeners;

 	/**
 	 * The list of addition checker items that are awaiting resolving.
 	 */
 	OpVector<AdditionCheckerItem> m_items;

 	AutoUpdateServerURL* m_autoupdate_server_url;
 	AutoUpdateXML* m_autoupdate_xml;
 };

 #endif // AUTOUPDATE_ADDITION_CHECKER_H
 #endif // AUTO_UPDATE_SUPPORT
--- a/adjunct/autoupdate/additioncheckerlistener.h
+++ b/adjunct/autoupdate/additioncheckerlistener.h
@@ -0,0 +1,49 @@
 /* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
 *
 * Copyright (C) 1995-2011 Opera Software AS.  All rights reserved.
 *
 * This file is part of the Opera web browser.	It may not be distributed
 * under any circumstances.
 *
 * @author Michal Zajaczkowski
 */

 #ifdef AUTO_UPDATE_SUPPORT

 #ifndef AUTOUPDATE_ADDITION_CHECKER_LISTENER_H
 #define AUTOUPDATE_ADDITION_CHECKER_LISTENER_H

 /**
 * The listener interface for the AdditionChecker. Implement this to get notifications about an addition resolve result.
 * In order to receive the notifications, register with the g_autoupdate_manager->AddListener().
 */
 class AdditionCheckerListener
 {
 public:
 	virtual ~AdditionCheckerListener() {};

 	/**
 	 * Called if an addition was able to resolve succesfully. You need to check if this call is for you, since notifications for ALL queued items
 	 * are broadcasted to ALL registered listeners.
 	 * You need to know what you have requested and ignore calls that are not meant for you.
 	 *
 	 * @param type - the type of the addition that was just resolved.
 	 * @param key - the key of the addition that was just resolved.
 	 * @param resource - a pointer to an UpdatableResource object representing the addition that was resolved. You receive the ownership of this
 	 *					 resource with this call, so be very careful to filter out the calls that are meant for you.
 	 */
 	virtual void OnAdditionResolved(UpdatableResource::UpdatableResourceType type, const OpStringC& key, UpdatableResource* resource) = 0;

 	/**
 	 * Called when an addition finally failed to resolve after a few retries (RESOLVE_MAX_RETRY_COUNT_PER_ITEM). Since this might still be 
 	 * a network or the autoupdate server issue it might have sense to ask about this addition later on.
 	 * The autoupdate server should be configured in such a way that is sends a meaningful resources for calls that request an addition that
 	 * can't be served by it, i.e. a request for a plugin that we don't offer for automatic installation still returns an XML with a plugin
 	 * description that has a <has-installer> XML element with a zero value.
 	 * This call is meant to inform that there was a problem with receiving any answer about this addition from the server.
 	 */
 	virtual void OnAdditionResolveFailed(UpdatableResource::UpdatableResourceType type, const OpStringC& key) = 0;
 };

 #endif // AUTOUPDATE_ADDITION_CHECKER_LISTENER_H
 #endif // AUTO_UPDATE_SUPPORT
--- a/adjunct/autoupdate/autoupdate_checker/.gitignore
+++ b/adjunct/autoupdate/autoupdate_checker/.gitignore
@@ -0,0 +1,4 @@
 /Output/
 *.*sdf
 *.suo
 *.user
--- a/adjunct/autoupdate/autoupdate_checker/adaptation_layer/global_storage.h
+++ b/adjunct/autoupdate/autoupdate_checker/adaptation_layer/global_storage.h
@@ -0,0 +1,70 @@
 /* -*- Mode: c++; tab-width: 2; indent-tabs-mode: s; c-basic-offset: 2 -*-
 **
 ** Copyright (C) 2012 Opera Software AS.  All rights reserved.
 **
 ** This file is part of the Opera web browser.  It may not be distributed
 ** under any circumstances.
 **
 **
 */

 #ifndef OAUC_GLOBAL_STORAGE_H
 #define OAUC_GLOBAL_STORAGE_H

 #include "adjunct/autoupdate/autoupdate_checker/common/common.h"

 namespace opera_update_checker
 {
  namespace global_storage
  {
    static const char* UUID_KEY = "UUID";
    static const char* LUT_KEY = "LUT";

    /** The class representing a system global storage e.g. the system registry on Windows. */
    class GlobalStorage
    {
    private:
      GlobalStorage(GlobalStorage&) {}
    protected:
      GlobalStorage() {}
      virtual ~GlobalStorage() {}
    public:
      /** The factory method. */
      static GlobalStorage* Create();
      /** The terminator */
      static void Destroy(GlobalStorage* storage);
      /** Sets Opera product name. Function is used only on OsX for meet
       *  Apple sandbox policy.
       *
       * @param[in] product_type - Opera product name.
       */
      virtual void SetOperaProductType(const char* product_type) {};
      /** Stores the data identified by the key in the storage.
       *
       * If the data, key pair entry already exists its data is updated.
       * Otherwise a new entry with the data, key pair is created and stored.
       *
       * @param[in] key - the key to identify the data by. Shouldn't be NULL.
       * @param[in] data - the data to be set. May be NULL in which case the given key,data pair entry should be deleted.
       * @param[in] data_len - the length of the data.
       *
       * @return StatusCode
       * @see StatusCode
       */
      virtual status::Status SetData(const char *key, const char* data, unsigned long data_len) = 0;
      /** Gets the data associated with the given key (NULL if there's no such data).
       * The caller is responsible for deleting the returned buffer.
       *
       * @param[in] key - the key to identify the data by. Shouldn't be NULL.
       * @param[in] data - a pointer to the buffer the data is put in.
       * @param[out] data_len - the length of the data.
       *
       * @return StatusCode
       * @see StatusCode
       */
      virtual status::Status GetData(const char *key, const char*& data, unsigned long& data_len) = 0;
    };
  }
 }

 #endif // OAUC_GLOBAL_STORAGE_H
--- a/adjunct/autoupdate/autoupdate_checker/adaptation_layer/ipc.h
+++ b/adjunct/autoupdate/autoupdate_checker/adaptation_layer/ipc.h
@@ -0,0 +1,133 @@
 /* -*- Mode: c++; tab-width: 2; indent-tabs-mode: s; c-basic-offset: 2 -*-
 **
 ** Copyright (C) 2012 Opera Software AS.  All rights reserved.
 **
 ** This file is part of the Opera web browser.  It may not be distributed
 ** under any circumstances.
 **
 */

 #ifndef OAUC_IPC_H
 # define OAUC_IPC_H

 #include "adjunct/autoupdate/autoupdate_checker/common/common.h"

 namespace opera_update_checker
 {
  namespace ipc
  {
    enum MessageType
    {
      AUTOUPDATE_STATUS
    };

    /** The struct describing a message passed between processes. */
    struct Message
    {
      Message() : data(NULLPTR), data_len(0), owns_data(false) {}
      ~Message()
      {
        if (owns_data)
          OAUC_DELETEA(data);
      }
      MessageType type;
      char* data;
      unsigned long data_len;
      bool owns_data;
    };

    class Channel;
    class Channel
    {
    private:
      Channel(Channel&) {}
    protected:
      Channel() {}
      virtual ~Channel() {}
    public:
      /** The mode of this channel. */
      enum ChannelMode
      {
        CHANNEL_MODE_READ = 0x1, /**< The channel may only be read from. */
        CHANNEL_MODE_WRITE = 0x2, /**< The channel may only be written to. */
        CHANNEL_MODE_READ_WRITE = CHANNEL_MODE_READ | CHANNEL_MODE_WRITE /**< The channel may be both read and written. */
      };

       /** The flow direction of this channel. */
      enum ChannelFlowDirection
      {
        FROM_SERVER_TO_CLIENT,
        FROM_CLIENT_TO_SERVER,
        BIDIRECTIONAL
      };

      /** The factory method.
       *
       * @param[in] is_server - If true it's the server part which creates this channel (the client otherwise).
       * @param[in] name - The unique id of the pipe to be used for creating pipe's name.
       * Its to ensure communicating processes have the same unique pipe name.
       * @param[in] mode - The mode of this channel.
       * @param[in] flow_direction - The flow direction of this channel.
       *
       * @see ChannelMode
       * @see ChannelType
       * @see ChannelFlowDirection
       */
      static Channel* Create(bool is_server, PidType id, ChannelMode mode, ChannelFlowDirection flow_direction);

      /** The terminator */
      static void Destroy(Channel* channel);

      /** Connects to the channel synchronously with a timeout.
       *
       * @param[in] timeout - The wait timeout. If it's RETURN_IMMEDIATELY there is no timeout.
       * If it's WAIT_INFINITELY this function blocks.
       *
       * @return StatusCode.
       * @see StatusCode.
       * @see OAUCTime.
       */
      virtual status::Status Connect(const OAUCTime& timeout) = 0;

      /** Returns true if the channel is connected. Otherwise false. */
      virtual bool IsConnected() = 0;

      /** Disconnects from the channel. */
      virtual void Disconnect() = 0;

      /** Sends a message synchronously with a timeout.
       *
       * @param[in] message - The message to be sent.
       * @param[in] timeout - The wait timeout. If it's RETURN_IMMEDIATELY there is no timeout.
       * If it's WAIT_INFINITELY this function blocks.
       *
       * @return StatusCode.
       * @see StatusCode.
       * @see Message.
       * @see OAUCTime.
       */
      virtual status::Status SendMessage(const Message& message, const OAUCTime& timeout) = 0;

      /** Gets a message synchronously with a timeout.
       *
       * @param[in] timeout - The wait timeout. If it's RETURN_IMMEDIATELY there is no timeout.
       * If it's WAIT_INFINITELY this function blocks.
       *
       * @return A pointer to a message or NULL on error. The caller must release the message when no longer needed.
       *
       * @see Message.
       * @see OAUCTime.
       */
      virtual const Message* GetMessage(const OAUCTime& timeout) = 0;
    };  // class Channel

    /** Returns the process Id of the current process, used for finding out
     * a unique name for a channel.
     * PidType is defined in platform-specific platform.h header and is an
     * integer type (ex. pid_t on POSIX, DWORD on Windows).
     */
    PidType GetCurrentProcessId();
  }  // namespace ipc
 }

 #endif // OAUC_IPC_H
--- a/adjunct/autoupdate/autoupdate_checker/adaptation_layer/network.h
+++ b/adjunct/autoupdate/autoupdate_checker/adaptation_layer/network.h
@@ -0,0 +1,109 @@
 /* -*- Mode: c++; tab-width: 2; indent-tabs-mode: s; c-basic-offset: 2 -*-
 **
 ** Copyright (C) 2012 Opera Software AS.  All rights reserved.
 **
 ** This file is part of the Opera web browser.  It may not be distributed
 ** under any circumstances.
 **
 */

 #ifndef OAUC_NETWORK_H
 # define OAUC_NETWORK_H

 # include "../common/common.h"

 namespace opera_update_checker
 {
  namespace network
  {
    /** The class hiding the details of the network layer using the HTTP protocol. */
    class Network
    {
    private:
      Network(Network&) {}
    protected:
      Network() {}
      virtual ~Network() {}
    public:
      /** Method which should be used when issuing the request. */
      enum Method
      {
        GET, /**< Use HTTP GET method. */
        POST /**< Use HTTP POST method. */
      };

      /** The struct encapsulating the request data. */
      struct RequestData
      {
        RequestData() : data(NULLPTR), data_mime_type(NULLPTR)
        {
        }
        /** The data. */
        const char* data;
        /** The length of the data. */
        unsigned data_length;
        /** The mime type of the data. May be NULL. It's ignored when the method is POST as application/x-www-form-urlencoded is assumed then. */
        const char* data_mime_type;
      };

    /** The location of the certificate to be used to verify https host. */
    enum CertificateLocation
    {
      /** The certificate is in a file. */
      CERTIFICATE_FILE,
      /** The certificate could be found in a directory. */
      CERTIFICATE_DIR,
      /** The certificate is in the memory. */
      CERTIFICATE_MEMORY
    };  // enum CertificateLocation

    /** Info about the certificate to be used. */
    struct CertificateInfo
    {
      /**
        * If location is CERTIFICATE_DIR or CERTIFICATE_FILE it's the path to
        * the certificate store/file. Otherwise it's certificate's data.
        * Must not be NULLPTR.
        */
      const char* certificate;
      /** Format of the certificate e.g. "PEM". Must not be NULLPTR. */
      const char* certificate_format;
      /** Specifies if the certificate is in the memory or in the filesystem. */
      CertificateLocation location;
    };  // struct CertificateInfo

      /** The response observer interface. Must be overridden by interested in getting the response. */
      class ResponseObserver
      {
      public:
        /** Called when some header is got. */
        virtual void OnHeaderReceived(const char* header, unsigned long data_len) = 0;
        /** Called when some data (other then an header) is got. */
        virtual void OnDataReceived(const char* data, unsigned long data_len) = 0;
      };

      /** The factory method. */
      static Network* Create();
      /** The terminator. */
      static void Destroy(Network* network);

      /** Sends the given request to a server given by the url using the specified method.
       * Blocks until the comunnication is done.
       *
       * @param url[in] - the server url to send the request to.
       * @param is_secure[in] - true if HTTPs protocol should be used.
       * @param cert[in] - relevant only if is_secure is true. Contains the certificate to be used for host verification. @see CertificateInfo.
       * @param method[in] - the method to be used. @see Method.
       * @param data[in] - the data to be sent. Some parts of it may be ignored depending on the method used. @see RequestData.
       * @param observer[in] - the observer to be notified about the response.
       *
       * @return StatusCode. @see StatusCode.
       */
      virtual status::Status SendHTTPRequest(const char* url, bool is_secure, const CertificateInfo* cert, Method method, const RequestData& data, ResponseObserver* observer) = 0;

      /** Gets the HTTP response code. The return value will be zero if no server response code has been received. */
      virtual unsigned GetResponseCode() = 0;
    };
  }
 }
 #endif // OAUC_NETWORK_H
--- a/adjunct/autoupdate/autoupdate_checker/adaptation_layer/protocol.h
+++ b/adjunct/autoupdate/autoupdate_checker/adaptation_layer/protocol.h
@@ -0,0 +1,142 @@
 /* -*- Mode: c++; tab-width: 2; indent-tabs-mode: s; c-basic-offset: 2 -*-
 **
 ** Copyright (C) 2012 Opera Software AS.  All rights reserved.
 **
 ** This file is part of the Opera web browser.  It may not be distributed
 ** under any circumstances.
 **
 **
 */

 #ifndef OAUC_XML_H
 # define OAUC_XML_H

 # include "../common/common.h"

 namespace opera_update_checker
 {
  namespace protocol
  {
    /** The class hiding the details of the request to the autoupdate server. */
    class Request
    {
    private:
      Request(Request&) {}
    protected:
      Request() {}
      virtual ~Request() {}
    public:
      /** The factory method returning an instance of this class. */
      static Request* Create();
      /** The terminator. */
      static void Destroy(Request* p);

      /** Provides the data needed to compose the main request part. The data is owned by the provider. */
      class UpdateDataProvider
      {
      public:
        virtual ~UpdateDataProvider() {}
        virtual const char* GetProductName() const = 0;
        virtual status::Status GetUUID(const char*&) const = 0;
        virtual status::Status GetLUT(const char*&) const = 0;
        virtual const char* GetOsName() const = 0;
        virtual const char* GetOsVersion() const = 0;
        virtual const char* GetArch() const = 0;
        virtual const char* GetPackage() const = 0;
        virtual const char* GetFirstRunVersion() const = 0;
        virtual const char* GetFirstRunTimestamp() const = 0;
        virtual const char* GetUserLocation() const = 0;
        virtual const char* GetDetectedLocation() const = 0;
        virtual const char* GetActiveLocation() const = 0;
        virtual const char* GetRegion() const = 0;
        virtual const char* GetProductLanguage() const = 0;
        virtual const char* GetProductVersion() const = 0;
      };

      /** Causes the main update check part (metrics, Opera binary) to be composed and added the the data.
       *
       * @param[in] provider - The update data provider.
       * @param[in] with_metrics - If true the metrics data will be included.
       *
       * @return StatusCode
       * @see StatusCode
       * @see UpdateDataProvider
       */
      virtual status::Status ComposeMainUpdatePart(const UpdateDataProvider& data_provider, bool with_metrics) = 0;
      /** Stores data about needed resources got from a product.
       *
       * @param[in] raw_data - the data to be added.
       *
       * @return StatusCode
       * @see StatusCode
       */
      virtual status::Status SetProductResourcesUpdatePart(const char* raw_data) = 0;
      /** Adds whole product data to the product specific data section.
       *
       * @param[in] provider - The update data provider.
       *
       * @return StatusCode
       * @see StatusCode
       * @see UpdateDataProvider
       */
      virtual status::Status AddProductUpdatePart(const UpdateDataProvider& provider) = 0;
      /** Gets the whole request data (might be NULL if no data has been composed/added).
       * The type and format of the data depends on the underlying implementation.
       */
      virtual const char* GetAllData() = 0;
      /** Clears the current content of the request. */
      virtual void Clear() = 0;
    };

    /** The class hiding the details of the request to the autoupdate server. */
    class Response
    {
    private:
      Response(Response&) {}
    protected:
      Response() {}
      virtual ~Response() {}
    public:
      /** The factory method returning an instance of this class. */
      static Response* Create();
      /** The terminator. */
      static void Destroy(Response* p);

      /** Adds the response data to be parsed when Parse() is called.
       *
       * @param[in] data - the response data.
       * @param[in] data_len - the length of the data.
       *
       * @return StatusCode
       * @see StatusCode
       */
      virtual status::Status AddData(const char* data, unsigned data_len) = 0;

      /** Parses the response data.
       *
       * @return StatusCode
       * @see StatusCode
       */
      virtual status::Status Parse() = 0;

      /** Gets UUID from the response. */
      virtual const char* GetUUID() = 0;

      /** Gets LUT (last update timestamp) from the response. */
      virtual const char* GetLUT() = 0;

      /** Gets the retry time. The retry time > 0 means the response is incomplete and the request
       * should be sent again after the given retry time. */
      virtual unsigned GetRetryTime() = 0;

      /** Gets the whole response data (might be NULL if no data has been composed/added).
       * The type and format of the data depends on the underlying implementation.
       */
      virtual const char* GetAllRawData() = 0;
      /** Clears the current content of the response. */
      virtual void Clear() = 0;
    };
  }
 }

 #endif // OAUC_XML_H
--- a/adjunct/autoupdate/autoupdate_checker/adaptation_layer/system_info.h
+++ b/adjunct/autoupdate/autoupdate_checker/adaptation_layer/system_info.h
@@ -0,0 +1,34 @@
 /* -*- Mode: c++; tab-width: 2; indent-tabs-mode: s; c-basic-offset: 2 -*-
 **
 ** Copyright (C) 2012 Opera Software AS.  All rights reserved.
 **
 ** This file is part of the Opera web browser.  It may not be distributed
 ** under any circumstances.
 **
 **
 */

 #ifndef OAUC_SYSTEM_INFO_H
 # define OAUC_SYSTEM_INFO_H

 namespace opera_update_checker
 {
  namespace system_info
  {
    /** The class providing information about the system. */
    class SystemInfo
    {
    public:
      /** Returns operating system's name e.g. "Windows". Never NULL. */
      static const char* GetOsName();
      /** Returns operating system's version e.g. "7" for Windows 7. Never NULL. */
      static const char* GetOsVersion();
      /** Returns computer's architecture e.g. "x86". Never NULL. */
      static const char* GetArch();
      /** Returns expected package type e.g. "EXE". Never NULL. */
      static const char* GetPackageType();
    };
  }
 }

 #endif // OAUC_SYSTEM_INFO_H
--- a/adjunct/autoupdate/autoupdate_checker/adaptation_layer/system_utils.h
+++ b/adjunct/autoupdate/autoupdate_checker/adaptation_layer/system_utils.h
@@ -0,0 +1,32 @@
 /* -*- Mode: c++; tab-width: 2; indent-tabs-mode: s; c-basic-offset: 2 -*-
 **
 ** Copyright (C) 2012 Opera Software AS.  All rights reserved.
 **
 ** This file is part of the Opera web browser.  It may not be distributed
 ** under any circumstances.
 **
 **
 */

 #ifndef OAUC_SYSTEM_UTILS_H
 # define OAUC_SYSTEM_UTILS_H

 #include "adjunct/autoupdate/autoupdate_checker/common/common.h"

 namespace opera_update_checker
 {
  namespace system_utils
  {
    /** The class providing the functionality using the underlying system's infrastructure. */
    class SystemUtils
    {
    public:
      /** Should sleep the calling process for the given amount of time in miliseconds. */
      static void Sleep(OAUCTime time);
      /** Case insensitive strncmp(). */
      static int strnicmp(const char* str1, const char* str2, size_t num_chars);
    };
  }
 }

 #endif // OAUC_SYSTEM_UTILS_H
--- a/adjunct/autoupdate/autoupdate_checker/autoupdate_checker_vc2010.sln
+++ b/adjunct/autoupdate/autoupdate_checker/autoupdate_checker_vc2010.sln
@@ -0,0 +1,50 @@

 Microsoft Visual Studio Solution File, Format Version 11.00
 # Visual C++ Express 2010
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "autoupdate_checker", "autoupdate_checker_vc2010.vcxproj", "{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}"
 	ProjectSection(ProjectDependencies) = postProject
 		{87EE9DA4-DE1E-4448-8324-183C98DCA588} = {87EE9DA4-DE1E-4448-8324-183C98DCA588}
 		{C406DAEC-0886-4771-8DEA-9D7329B46CC1} = {C406DAEC-0886-4771-8DEA-9D7329B46CC1}
 	EndProjectSection
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tinyxml", "platforms\universal_adaptation_layer\tinyxml\tinyxml_lib.vcxproj", "{C406DAEC-0886-4771-8DEA-9D7329B46CC1}"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libcurl", "platforms\universal_adaptation_layer\network\curl\lib\libcurl.vcxproj", "{87EE9DA4-DE1E-4448-8324-183C98DCA588}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Win32 = Debug|Win32
 		Debug|x64 = Debug|x64
 		Release|Win32 = Release|Win32
 		Release|x64 = Release|x64
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
 		{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}.Debug|Win32.ActiveCfg = Debug|Win32
 		{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}.Debug|Win32.Build.0 = Debug|Win32
 		{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}.Debug|x64.ActiveCfg = Debug|x64
 		{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}.Debug|x64.Build.0 = Debug|x64
 		{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}.Release|Win32.ActiveCfg = Release|Win32
 		{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}.Release|Win32.Build.0 = Release|Win32
 		{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}.Release|x64.ActiveCfg = Release|x64
 		{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}.Release|x64.Build.0 = Release|x64
 		{C406DAEC-0886-4771-8DEA-9D7329B46CC1}.Debug|Win32.ActiveCfg = Debug|Win32
 		{C406DAEC-0886-4771-8DEA-9D7329B46CC1}.Debug|Win32.Build.0 = Debug|Win32
 		{C406DAEC-0886-4771-8DEA-9D7329B46CC1}.Debug|x64.ActiveCfg = Debug|x64
 		{C406DAEC-0886-4771-8DEA-9D7329B46CC1}.Debug|x64.Build.0 = Debug|x64
 		{C406DAEC-0886-4771-8DEA-9D7329B46CC1}.Release|Win32.ActiveCfg = Release|Win32
 		{C406DAEC-0886-4771-8DEA-9D7329B46CC1}.Release|Win32.Build.0 = Release|Win32
 		{C406DAEC-0886-4771-8DEA-9D7329B46CC1}.Release|x64.ActiveCfg = Release|x64
 		{C406DAEC-0886-4771-8DEA-9D7329B46CC1}.Release|x64.Build.0 = Release|x64
 		{87EE9DA4-DE1E-4448-8324-183C98DCA588}.Debug|Win32.ActiveCfg = Debug|Win32
 		{87EE9DA4-DE1E-4448-8324-183C98DCA588}.Debug|Win32.Build.0 = Debug|Win32
 		{87EE9DA4-DE1E-4448-8324-183C98DCA588}.Debug|x64.ActiveCfg = Debug|x64
 		{87EE9DA4-DE1E-4448-8324-183C98DCA588}.Debug|x64.Build.0 = Debug|x64
 		{87EE9DA4-DE1E-4448-8324-183C98DCA588}.Release|Win32.ActiveCfg = Release|Win32
 		{87EE9DA4-DE1E-4448-8324-183C98DCA588}.Release|Win32.Build.0 = Release|Win32
 		{87EE9DA4-DE1E-4448-8324-183C98DCA588}.Release|x64.ActiveCfg = Release|x64
 		{87EE9DA4-DE1E-4448-8324-183C98DCA588}.Release|x64.Build.0 = Release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 EndGlobal
--- a/adjunct/autoupdate/autoupdate_checker/autoupdate_checker_vc2010.vcxproj
+++ b/adjunct/autoupdate/autoupdate_checker/autoupdate_checker_vc2010.vcxproj
@@ -0,0 +1,447 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup Label="ProjectConfigurations">
    <ProjectConfiguration Include="Debug|Win32">
      <Configuration>Debug</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Debug|x64">
      <Configuration>Debug</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Instrumented|Win32">
      <Configuration>Instrumented</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Instrumented|x64">
      <Configuration>Instrumented</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="PGO|Win32">
      <Configuration>PGO</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="PGO|x64">
      <Configuration>PGO</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|Win32">
      <Configuration>Release</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|x64">
      <Configuration>Release</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="vTune|Win32">
      <Configuration>vTune</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="vTune|x64">
      <Configuration>vTune</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="autoupdatechecker.cpp" />
    <ClCompile Include="platforms\universal_adaptation_layer\networkimpl.cpp" />
    <ClCompile Include="platforms\universal_adaptation_layer\protocolimpl.cpp" />
    <ClCompile Include="platforms\windows\globalstorageimpl.cpp" />
    <ClCompile Include="platforms\windows\ipcimpl.cpp" />
    <ClCompile Include="platforms\windows\main_win.cpp" />
    <ClCompile Include="platforms\windows\systeminfoimpl.cpp" />
    <ClCompile Include="platforms\windows\systemutilsimpl.cpp" />
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="adaptation_layer\global_storage.h" />
    <ClInclude Include="adaptation_layer\ipc.h" />
    <ClInclude Include="adaptation_layer\ipcconfig.h" />
    <ClInclude Include="adaptation_layer\message_types.h" />
    <ClInclude Include="adaptation_layer\network.h" />
    <ClInclude Include="adaptation_layer\protocol.h" />
    <ClInclude Include="adaptation_layer\system_info.h" />
    <ClInclude Include="adaptation_layer\system_utils.h" />
    <ClInclude Include="autoupdatechecker.h" />
    <ClInclude Include="common\common.h" />
    <ClInclude Include="platforms\universal_adaptation_layer\all_includes.h" />
    <ClInclude Include="platforms\universal_adaptation_layer\networkimpl.h" />
    <ClInclude Include="platforms\universal_adaptation_layer\protocolimpl.h" />
    <ClInclude Include="platforms\windows\includes\globalstorageimpl.h" />
    <ClInclude Include="platforms\windows\includes\ipcconfig.h" />
    <ClInclude Include="platforms\windows\includes\ipcimpl.h" />
    <ClInclude Include="platforms\windows\includes\platform.h" />
  </ItemGroup>
  <PropertyGroup Label="Globals">
    <ProjectGuid>{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}</ProjectGuid>
    <RootNamespace>autoupdate_checker_vc2010</RootNamespace>
    <ProjectName>autoupdate_checker</ProjectName>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='vTune|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='vTune|x64'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='PGO|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='PGO|x64'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Instrumented|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Instrumented|x64'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ImportGroup Label="ExtensionSettings">
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='vTune|Win32'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='vTune|x64'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='PGO|Win32'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='PGO|x64'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Instrumented|Win32'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Instrumented|x64'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <LinkIncremental>true</LinkIncremental>
    <OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
    <IntDir>Output\$(ProjectName)\</IntDir>
    <TargetName>opera_autoupdate</TargetName>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <LinkIncremental>true</LinkIncremental>
    <OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
    <IntDir>Output\$(ProjectName)\</IntDir>
    <TargetName>opera_autoupdate</TargetName>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='vTune|Win32'">
    <OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='vTune|x64'">
    <OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='PGO|Win32'">
    <OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='PGO|x64'">
    <OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Instrumented|Win32'">
    <OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Instrumented|x64'">
    <OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <IntDir>Output\$(ProjectName)\</IntDir>
    <TargetName>opera_autoupdate</TargetName>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <IntDir>Output\$(ProjectName)\</IntDir>
    <TargetName>opera_autoupdate</TargetName>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='vTune|Win32'">
    <IntDir>Output\$(ProjectName)\</IntDir>
    <TargetName>opera_autoupdate</TargetName>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='vTune|x64'">
    <IntDir>Output\$(ProjectName)\</IntDir>
    <TargetName>opera_autoupdate</TargetName>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='PGO|Win32'">
    <IntDir>Output\$(ProjectName)\</IntDir>
    <TargetName>opera_autoupdate</TargetName>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='PGO|x64'">
    <IntDir>Output\$(ProjectName)\</IntDir>
    <TargetName>opera_autoupdate</TargetName>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Instrumented|Win32'">
    <IntDir>Output\$(ProjectName)\</IntDir>
    <TargetName>opera_autoupdate</TargetName>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Instrumented|x64'">
    <IntDir>Output\$(ProjectName)\</IntDir>
    <TargetName>opera_autoupdate</TargetName>
  </PropertyGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
      <PreprocessorDefinitions>OAUC_PLATFORM_INCLUDES="platforms/windows/includes/platform.h";CURL_STATICLIB;CURL_DISABLE_GOPHER;CURL_DISABLE_SMTP;CURL_DISABLE_IMAP;CURL_DISABLE_POP3;CURL_DISABLE_TFTP;CURL_DISABLE_TELNET;CURL_DISABLE_DICT;CURL_DISABLE_PROXY;CURL_DISABLE_LDAPS;CURL_DISABLE_LDAP;CURL_DISABLE_FILE;CURL_DISABLE_FTP;CURL_DISABLE_RTSP;USE_OPENSSL;USE_SSLEAY;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions);</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>.;platforms/universal_adaptation_layer/network/openssl/include/;../../..</AdditionalIncludeDirectories>
      <PrecompiledHeader>NotUsing</PrecompiledHeader>
      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
      <ExceptionHandling>Sync</ExceptionHandling>
    </ClCompile>
    <Link>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <AdditionalLibraryDirectories>Output;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
      <AdditionalDependencies>libeay32.lib;ssleay32.lib;tinyxml.lib;ws2_32.lib;libcurl.lib;%(AdditionalDependencies)</AdditionalDependencies>
      <ShowProgress>NotSet</ShowProgress>
      <SubSystem>Windows</SubSystem>
    </Link>
    <PreBuildEvent>
      <Command>
      </Command>
    </PreBuildEvent>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
      <PreprocessorDefinitions>OAUC_PLATFORM_INCLUDES="platforms/windows/includes/platform.h";CURL_STATICLIB;CURL_DISABLE_GOPHER;CURL_DISABLE_SMTP;CURL_DISABLE_IMAP;CURL_DISABLE_POP3;CURL_DISABLE_TFTP;CURL_DISABLE_TELNET;CURL_DISABLE_DICT;CURL_DISABLE_PROXY;CURL_DISABLE_LDAPS;CURL_DISABLE_LDAP;CURL_DISABLE_FILE;CURL_DISABLE_FTP;CURL_DISABLE_RTSP;USE_OPENSSL;USE_SSLEAY;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions);</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>.;platforms/universal_adaptation_layer/network/openssl/include/;../../..</AdditionalIncludeDirectories>
      <PrecompiledHeader>NotUsing</PrecompiledHeader>
      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
      <ExceptionHandling>Sync</ExceptionHandling>
    </ClCompile>
    <Link>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <AdditionalLibraryDirectories>Output;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
      <AdditionalDependencies>libeay32_x64.lib;ssleay32_x64.lib;tinyxml.lib;ws2_32.lib;libcurl.lib;%(AdditionalDependencies)</AdditionalDependencies>
      <ShowProgress>NotSet</ShowProgress>
      <SubSystem>Windows</SubSystem>
    </Link>
    <PreBuildEvent>
      <Command>
      </Command>
    </PreBuildEvent>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <PreprocessorDefinitions>OAUC_PLATFORM_INCLUDES="platforms/windows/includes/platform.h";NDEBUG;CURL_STATICLIB;CURL_DISABLE_GOPHER;CURL_DISABLE_SMTP;CURL_DISABLE_IMAP;CURL_DISABLE_POP3;CURL_DISABLE_TFTP;CURL_DISABLE_TELNET;CURL_DISABLE_DICT;CURL_DISABLE_PROXY;CURL_DISABLE_LDAPS;CURL_DISABLE_LDAP;CURL_DISABLE_FILE;CURL_DISABLE_FTP;CURL_DISABLE_RTSP;USE_OPENSSL;USE_SSLEAY;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions);</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>.;platforms/universal_adaptation_layer/network/openssl/include/;../../..</AdditionalIncludeDirectories>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <ExceptionHandling>Sync</ExceptionHandling>
    </ClCompile>
    <Link>
      <GenerateDebugInformation>false</GenerateDebugInformation>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <AdditionalDependencies>libeay32.lib;ssleay32.lib;tinyxml.lib;ws2_32.lib;libcurl.lib;nothrownew.obj;%(AdditionalDependencies)</AdditionalDependencies>
      <AdditionalLibraryDirectories>Output;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
      <SubSystem>Windows</SubSystem>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <PreprocessorDefinitions>OAUC_PLATFORM_INCLUDES="platforms/windows/includes/platform.h";NDEBUG;CURL_STATICLIB;CURL_DISABLE_GOPHER;CURL_DISABLE_SMTP;CURL_DISABLE_IMAP;CURL_DISABLE_POP3;CURL_DISABLE_TFTP;CURL_DISABLE_TELNET;CURL_DISABLE_DICT;CURL_DISABLE_PROXY;CURL_DISABLE_LDAPS;CURL_DISABLE_LDAP;CURL_DISABLE_FILE;CURL_DISABLE_FTP;CURL_DISABLE_RTSP;USE_OPENSSL;USE_SSLEAY;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions);</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>.;platforms/universal_adaptation_layer/network/openssl/include/;../../..</AdditionalIncludeDirectories>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <ExceptionHandling>Sync</ExceptionHandling>
    </ClCompile>
    <Link>
      <GenerateDebugInformation>false</GenerateDebugInformation>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <AdditionalDependencies>libeay32_x64.lib;ssleay32_x64.lib;tinyxml.lib;ws2_32.lib;libcurl.lib;nothrownew.obj;%(AdditionalDependencies)</AdditionalDependencies>
      <AdditionalLibraryDirectories>Output;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
      <SubSystem>Windows</SubSystem>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='vTune|Win32'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <PreprocessorDefinitions>OAUC_PLATFORM_INCLUDES="platforms/windows/includes/platform.h";NDEBUG;CURL_STATICLIB;CURL_DISABLE_GOPHER;CURL_DISABLE_SMTP;CURL_DISABLE_IMAP;CURL_DISABLE_POP3;CURL_DISABLE_TFTP;CURL_DISABLE_TELNET;CURL_DISABLE_DICT;CURL_DISABLE_PROXY;CURL_DISABLE_LDAPS;CURL_DISABLE_LDAP;CURL_DISABLE_FILE;CURL_DISABLE_FTP;CURL_DISABLE_RTSP;USE_OPENSSL;USE_SSLEAY;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions);</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>.;platforms/universal_adaptation_layer/network/openssl/include/;../../..</AdditionalIncludeDirectories>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <ExceptionHandling>Sync</ExceptionHandling>
    </ClCompile>
    <Link>
      <GenerateDebugInformation>false</GenerateDebugInformation>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <AdditionalDependencies>libeay32.lib;ssleay32.lib;tinyxml.lib;ws2_32.lib;libcurl.lib;%(AdditionalDependencies)</AdditionalDependencies>
      <AdditionalLibraryDirectories>Output;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
      <SubSystem>Windows</SubSystem>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='vTune|x64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <PreprocessorDefinitions>OAUC_PLATFORM_INCLUDES="platforms/windows/includes/platform.h";NDEBUG;CURL_STATICLIB;CURL_DISABLE_GOPHER;CURL_DISABLE_SMTP;CURL_DISABLE_IMAP;CURL_DISABLE_POP3;CURL_DISABLE_TFTP;CURL_DISABLE_TELNET;CURL_DISABLE_DICT;CURL_DISABLE_PROXY;CURL_DISABLE_LDAPS;CURL_DISABLE_LDAP;CURL_DISABLE_FILE;CURL_DISABLE_FTP;CURL_DISABLE_RTSP;USE_OPENSSL;USE_SSLEAY;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions);</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>.;platforms/universal_adaptation_layer/network/openssl/include/;../../..</AdditionalIncludeDirectories>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <ExceptionHandling>Sync</ExceptionHandling>
    </ClCompile>
    <Link>
      <GenerateDebugInformation>false</GenerateDebugInformation>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <AdditionalDependencies>libeay32_x64.lib;ssleay32_x64.lib;tinyxml.lib;ws2_32.lib;libcurl.lib;%(AdditionalDependencies)</AdditionalDependencies>
      <AdditionalLibraryDirectories>Output;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
      <SubSystem>Windows</SubSystem>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='PGO|Win32'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <PreprocessorDefinitions>OAUC_PLATFORM_INCLUDES="platforms/windows/includes/platform.h";NDEBUG;CURL_STATICLIB;CURL_DISABLE_GOPHER;CURL_DISABLE_SMTP;CURL_DISABLE_IMAP;CURL_DISABLE_POP3;CURL_DISABLE_TFTP;CURL_DISABLE_TELNET;CURL_DISABLE_DICT;CURL_DISABLE_PROXY;CURL_DISABLE_LDAPS;CURL_DISABLE_LDAP;CURL_DISABLE_FILE;CURL_DISABLE_FTP;CURL_DISABLE_RTSP;USE_OPENSSL;USE_SSLEAY;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions);</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>.;platforms/universal_adaptation_layer/network/openssl/include/;../../..</AdditionalIncludeDirectories>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <ExceptionHandling>Sync</ExceptionHandling>
    </ClCompile>
    <Link>
      <GenerateDebugInformation>false</GenerateDebugInformation>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <AdditionalDependencies>libeay32.lib;ssleay32.lib;tinyxml.lib;ws2_32.lib;libcurl.lib;%(AdditionalDependencies)</AdditionalDependencies>
      <AdditionalLibraryDirectories>Output;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
      <SubSystem>Windows</SubSystem>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='PGO|x64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <PreprocessorDefinitions>OAUC_PLATFORM_INCLUDES="platforms/windows/includes/platform.h";NDEBUG;CURL_STATICLIB;CURL_DISABLE_GOPHER;CURL_DISABLE_SMTP;CURL_DISABLE_IMAP;CURL_DISABLE_POP3;CURL_DISABLE_TFTP;CURL_DISABLE_TELNET;CURL_DISABLE_DICT;CURL_DISABLE_PROXY;CURL_DISABLE_LDAPS;CURL_DISABLE_LDAP;CURL_DISABLE_FILE;CURL_DISABLE_FTP;CURL_DISABLE_RTSP;USE_OPENSSL;USE_SSLEAY;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions);</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>.;platforms/universal_adaptation_layer/network/openssl/include/;../../..</AdditionalIncludeDirectories>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <ExceptionHandling>Sync</ExceptionHandling>
    </ClCompile>
    <Link>
      <GenerateDebugInformation>false</GenerateDebugInformation>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <AdditionalDependencies>libeay32_x64.lib;ssleay32_x64.lib;tinyxml.lib;ws2_32.lib;libcurl.lib;%(AdditionalDependencies)</AdditionalDependencies>
      <AdditionalLibraryDirectories>Output;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
      <SubSystem>Windows</SubSystem>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Instrumented|Win32'">
    <ClCompile>