| Index: chrome/browser/policy/device_management_service.cc
|
| diff --git a/chrome/browser/policy/device_management_service.cc b/chrome/browser/policy/device_management_service.cc
|
| deleted file mode 100644
|
| index 7cdc87d30f3cc1e425d12e65c6be76982812fd76..0000000000000000000000000000000000000000
|
| --- a/chrome/browser/policy/device_management_service.cc
|
| +++ /dev/null
|
| @@ -1,650 +0,0 @@
|
| -// Copyright (c) 2012 The Chromium Authors. All rights reserved.
|
| -// Use of this source code is governed by a BSD-style license that can be
|
| -// found in the LICENSE file.
|
| -
|
| -#include "chrome/browser/policy/device_management_service.h"
|
| -
|
| -#include <utility>
|
| -
|
| -#include "base/bind.h"
|
| -#include "base/compiler_specific.h"
|
| -#include "base/message_loop.h"
|
| -#include "base/message_loop_proxy.h"
|
| -#include "base/stringprintf.h"
|
| -#include "base/sys_info.h"
|
| -#include "chrome/browser/browser_process.h"
|
| -#include "chrome/browser/net/basic_http_user_agent_settings.h"
|
| -#include "chrome/browser/net/chrome_net_log.h"
|
| -#include "chrome/common/chrome_version_info.h"
|
| -#include "content/public/browser/browser_thread.h"
|
| -#include "content/public/common/content_client.h"
|
| -#include "googleurl/src/gurl.h"
|
| -#include "net/base/escape.h"
|
| -#include "net/base/host_resolver.h"
|
| -#include "net/base/load_flags.h"
|
| -#include "net/base/net_errors.h"
|
| -#include "net/base/ssl_config_service_defaults.h"
|
| -#include "net/cookies/cookie_monster.h"
|
| -#include "net/http/http_network_layer.h"
|
| -#include "net/http/http_response_headers.h"
|
| -#include "net/proxy/proxy_service.h"
|
| -#include "net/url_request/url_fetcher.h"
|
| -#include "net/url_request/url_request_context.h"
|
| -#include "net/url_request/url_request_context_getter.h"
|
| -#include "net/url_request/url_request_status.h"
|
| -
|
| -#if defined(OS_CHROMEOS)
|
| -#include "chrome/browser/chromeos/system/statistics_provider.h"
|
| -#endif
|
| -
|
| -using content::BrowserThread;
|
| -
|
| -namespace em = enterprise_management;
|
| -
|
| -namespace policy {
|
| -
|
| -namespace {
|
| -
|
| -const char kValueAgent[] = "%s %s(%s)";
|
| -const char kValuePlatform[] = "%s|%s|%s";
|
| -
|
| -const char kPostContentType[] = "application/protobuf";
|
| -
|
| -const char kServiceTokenAuthHeader[] = "Authorization: GoogleLogin auth=";
|
| -const char kDMTokenAuthHeader[] = "Authorization: GoogleDMToken token=";
|
| -
|
| -// Number of times to retry on ERR_NETWORK_CHANGED errors.
|
| -const int kMaxNetworkChangedRetries = 3;
|
| -
|
| -// HTTP Error Codes of the DM Server with their concrete meanings in the context
|
| -// of the DM Server communication.
|
| -const int kSuccess = 200;
|
| -const int kInvalidArgument = 400;
|
| -const int kInvalidAuthCookieOrDMToken = 401;
|
| -const int kMissingLicenses = 402;
|
| -const int kDeviceManagementNotAllowed = 403;
|
| -const int kInvalidURL = 404; // This error is not coming from the GFE.
|
| -const int kInvalidSerialNumber = 405;
|
| -const int kDeviceIdConflict = 409;
|
| -const int kDeviceNotFound = 410;
|
| -const int kPendingApproval = 412;
|
| -const int kInternalServerError = 500;
|
| -const int kServiceUnavailable = 503;
|
| -const int kPolicyNotFound = 902; // This error is not sent as HTTP status code.
|
| -
|
| -#if defined(OS_CHROMEOS)
|
| -// Machine info keys.
|
| -const char kMachineInfoHWClass[] = "hardware_class";
|
| -const char kMachineInfoBoard[] = "CHROMEOS_RELEASE_BOARD";
|
| -#endif
|
| -
|
| -bool IsProxyError(const net::URLRequestStatus status) {
|
| - switch (status.error()) {
|
| - case net::ERR_PROXY_CONNECTION_FAILED:
|
| - case net::ERR_TUNNEL_CONNECTION_FAILED:
|
| - case net::ERR_PROXY_AUTH_UNSUPPORTED:
|
| - case net::ERR_HTTPS_PROXY_TUNNEL_RESPONSE:
|
| - case net::ERR_MANDATORY_PROXY_CONFIGURATION_FAILED:
|
| - case net::ERR_PROXY_CERTIFICATE_INVALID:
|
| - case net::ERR_SOCKS_CONNECTION_FAILED:
|
| - case net::ERR_SOCKS_CONNECTION_HOST_UNREACHABLE:
|
| - return true;
|
| - }
|
| - return false;
|
| -}
|
| -
|
| -bool IsProtobufMimeType(const net::URLFetcher* fetcher) {
|
| - return fetcher->GetResponseHeaders()->HasHeaderValue(
|
| - "content-type", "application/x-protobuffer");
|
| -}
|
| -
|
| -bool FailedWithProxy(const net::URLFetcher* fetcher) {
|
| - if ((fetcher->GetLoadFlags() & net::LOAD_BYPASS_PROXY) != 0) {
|
| - // The request didn't use a proxy.
|
| - return false;
|
| - }
|
| -
|
| - if (!fetcher->GetStatus().is_success() &&
|
| - IsProxyError(fetcher->GetStatus())) {
|
| - LOG(WARNING) << "Proxy failed while contacting dmserver.";
|
| - return true;
|
| - }
|
| -
|
| - if (fetcher->GetStatus().is_success() &&
|
| - fetcher->GetResponseCode() == kSuccess &&
|
| - fetcher->WasFetchedViaProxy() &&
|
| - !IsProtobufMimeType(fetcher)) {
|
| - // The proxy server can be misconfigured but pointing to an existing
|
| - // server that replies to requests. Try to recover if a successful
|
| - // request that went through a proxy returns an unexpected mime type.
|
| - LOG(WARNING) << "Got bad mime-type in response from dmserver that was "
|
| - << "fetched via a proxy.";
|
| - return true;
|
| - }
|
| -
|
| - return false;
|
| -}
|
| -
|
| -const char* UserAffiliationToString(UserAffiliation affiliation) {
|
| - switch (affiliation) {
|
| - case USER_AFFILIATION_MANAGED:
|
| - return dm_protocol::kValueUserAffiliationManaged;
|
| - case USER_AFFILIATION_NONE:
|
| - return dm_protocol::kValueUserAffiliationNone;
|
| - }
|
| - NOTREACHED() << "Invalid user affiliation " << affiliation;
|
| - return dm_protocol::kValueUserAffiliationNone;
|
| -}
|
| -
|
| -const char* JobTypeToRequestType(DeviceManagementRequestJob::JobType type) {
|
| - switch (type) {
|
| - case DeviceManagementRequestJob::TYPE_AUTO_ENROLLMENT:
|
| - return dm_protocol::kValueRequestAutoEnrollment;
|
| - case DeviceManagementRequestJob::TYPE_REGISTRATION:
|
| - return dm_protocol::kValueRequestRegister;
|
| - case DeviceManagementRequestJob::TYPE_POLICY_FETCH:
|
| - return dm_protocol::kValueRequestPolicy;
|
| - case DeviceManagementRequestJob::TYPE_UNREGISTRATION:
|
| - return dm_protocol::kValueRequestUnregister;
|
| - }
|
| - NOTREACHED() << "Invalid job type " << type;
|
| - return "";
|
| -}
|
| -
|
| -const std::string& GetAgentString() {
|
| - CR_DEFINE_STATIC_LOCAL(std::string, agent, ());
|
| - if (!agent.empty())
|
| - return agent;
|
| -
|
| - chrome::VersionInfo version_info;
|
| - agent = base::StringPrintf(kValueAgent,
|
| - version_info.Name().c_str(),
|
| - version_info.Version().c_str(),
|
| - version_info.LastChange().c_str());
|
| - return agent;
|
| -}
|
| -
|
| -const std::string& GetPlatformString() {
|
| - CR_DEFINE_STATIC_LOCAL(std::string, platform, ());
|
| - if (!platform.empty())
|
| - return platform;
|
| -
|
| - std::string os_name(base::SysInfo::OperatingSystemName());
|
| - std::string os_hardware(base::SysInfo::OperatingSystemArchitecture());
|
| -
|
| -#if defined(OS_CHROMEOS)
|
| - chromeos::system::StatisticsProvider* provider =
|
| - chromeos::system::StatisticsProvider::GetInstance();
|
| -
|
| - std::string hwclass;
|
| - std::string board;
|
| - if (!provider->GetMachineStatistic(kMachineInfoHWClass, &hwclass) ||
|
| - !provider->GetMachineStatistic(kMachineInfoBoard, &board)) {
|
| - LOG(ERROR) << "Failed to get machine information";
|
| - }
|
| - os_name += ",CrOS," + board;
|
| - os_hardware += "," + hwclass;
|
| -#endif
|
| -
|
| - std::string os_version("-");
|
| -#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_CHROMEOS)
|
| - int32 os_major_version = 0;
|
| - int32 os_minor_version = 0;
|
| - int32 os_bugfix_version = 0;
|
| - base::SysInfo::OperatingSystemVersionNumbers(&os_major_version,
|
| - &os_minor_version,
|
| - &os_bugfix_version);
|
| - os_version = base::StringPrintf("%d.%d.%d",
|
| - os_major_version,
|
| - os_minor_version,
|
| - os_bugfix_version);
|
| -#endif
|
| -
|
| - platform = base::StringPrintf(kValuePlatform,
|
| - os_name.c_str(),
|
| - os_hardware.c_str(),
|
| - os_version.c_str());
|
| - return platform;
|
| -}
|
| -
|
| -// Custom request context implementation that allows to override the user agent,
|
| -// amongst others. Wraps a baseline request context from which we reuse the
|
| -// networking components.
|
| -class DeviceManagementRequestContext : public net::URLRequestContext {
|
| - public:
|
| - explicit DeviceManagementRequestContext(net::URLRequestContext* base_context);
|
| - virtual ~DeviceManagementRequestContext();
|
| -
|
| - private:
|
| - BasicHttpUserAgentSettings basic_http_user_agent_settings_;
|
| -};
|
| -
|
| -DeviceManagementRequestContext::DeviceManagementRequestContext(
|
| - net::URLRequestContext* base_context)
|
| - // Use sane Accept-Language and Accept-Charset values for our purposes.
|
| - : basic_http_user_agent_settings_("*", "*") {
|
| - // Share resolver, proxy service and ssl bits with the baseline context. This
|
| - // is important so we don't make redundant requests (e.g. when resolving proxy
|
| - // auto configuration).
|
| - set_net_log(base_context->net_log());
|
| - set_host_resolver(base_context->host_resolver());
|
| - set_proxy_service(base_context->proxy_service());
|
| - set_ssl_config_service(base_context->ssl_config_service());
|
| -
|
| - // Share the http session.
|
| - set_http_transaction_factory(
|
| - new net::HttpNetworkLayer(
|
| - base_context->http_transaction_factory()->GetSession()));
|
| -
|
| - // No cookies, please.
|
| - set_cookie_store(new net::CookieMonster(NULL, NULL));
|
| -
|
| - set_http_user_agent_settings(&basic_http_user_agent_settings_);
|
| -}
|
| -
|
| -DeviceManagementRequestContext::~DeviceManagementRequestContext() {
|
| - delete http_transaction_factory();
|
| -}
|
| -
|
| -// Request context holder.
|
| -class DeviceManagementRequestContextGetter
|
| - : public net::URLRequestContextGetter {
|
| - public:
|
| - explicit DeviceManagementRequestContextGetter(
|
| - net::URLRequestContextGetter* base_context_getter)
|
| - : base_context_getter_(base_context_getter) {}
|
| -
|
| - // Overridden from net::URLRequestContextGetter:
|
| - virtual net::URLRequestContext* GetURLRequestContext() OVERRIDE;
|
| - virtual scoped_refptr<base::SingleThreadTaskRunner>
|
| - GetNetworkTaskRunner() const OVERRIDE;
|
| -
|
| - protected:
|
| - virtual ~DeviceManagementRequestContextGetter() {}
|
| -
|
| - private:
|
| - scoped_ptr<net::URLRequestContext> context_;
|
| - scoped_refptr<net::URLRequestContextGetter> base_context_getter_;
|
| -};
|
| -
|
| -
|
| -net::URLRequestContext*
|
| -DeviceManagementRequestContextGetter::GetURLRequestContext() {
|
| - DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
|
| - if (!context_.get()) {
|
| - context_.reset(new DeviceManagementRequestContext(
|
| - base_context_getter_->GetURLRequestContext()));
|
| - }
|
| -
|
| - return context_.get();
|
| -}
|
| -
|
| -scoped_refptr<base::SingleThreadTaskRunner>
|
| -DeviceManagementRequestContextGetter::GetNetworkTaskRunner() const {
|
| - return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
|
| -}
|
| -
|
| -} // namespace
|
| -
|
| -// Request job implementation used with DeviceManagementService.
|
| -class DeviceManagementRequestJobImpl : public DeviceManagementRequestJob {
|
| - public:
|
| - DeviceManagementRequestJobImpl(JobType type,
|
| - DeviceManagementService* service);
|
| - virtual ~DeviceManagementRequestJobImpl();
|
| -
|
| - // Handles the URL request response.
|
| - void HandleResponse(const net::URLRequestStatus& status,
|
| - int response_code,
|
| - const net::ResponseCookies& cookies,
|
| - const std::string& data);
|
| -
|
| - // Gets the URL to contact.
|
| - GURL GetURL(const std::string& server_url);
|
| -
|
| - // Configures the fetcher, setting up payload and headers.
|
| - void ConfigureRequest(net::URLFetcher* fetcher);
|
| -
|
| - // Returns true if this job should be retried. |fetcher| has just completed,
|
| - // and can be inspected to determine if the request failed and should be
|
| - // retried.
|
| - bool ShouldRetry(const net::URLFetcher* fetcher);
|
| -
|
| - // Invoked right before retrying this job.
|
| - void PrepareRetry();
|
| -
|
| - protected:
|
| - // DeviceManagementRequestJob:
|
| - virtual void Run() OVERRIDE;
|
| -
|
| - private:
|
| - // Invokes the callback with the given error code.
|
| - void ReportError(DeviceManagementStatus code);
|
| -
|
| - // Pointer to the service this job is associated with.
|
| - DeviceManagementService* service_;
|
| -
|
| - // Whether the BYPASS_PROXY flag should be set by ConfigureRequest().
|
| - bool bypass_proxy_;
|
| -
|
| - // Number of times that this job has been retried due to ERR_NETWORK_CHANGED.
|
| - int retries_count_;
|
| -
|
| - DISALLOW_COPY_AND_ASSIGN(DeviceManagementRequestJobImpl);
|
| -};
|
| -
|
| -DeviceManagementRequestJobImpl::DeviceManagementRequestJobImpl(
|
| - JobType type,
|
| - DeviceManagementService* service)
|
| - : DeviceManagementRequestJob(type),
|
| - service_(service),
|
| - bypass_proxy_(false),
|
| - retries_count_(0) {}
|
| -
|
| -DeviceManagementRequestJobImpl::~DeviceManagementRequestJobImpl() {
|
| - service_->RemoveJob(this);
|
| -}
|
| -
|
| -void DeviceManagementRequestJobImpl::Run() {
|
| - service_->AddJob(this);
|
| -}
|
| -
|
| -void DeviceManagementRequestJobImpl::HandleResponse(
|
| - const net::URLRequestStatus& status,
|
| - int response_code,
|
| - const net::ResponseCookies& cookies,
|
| - const std::string& data) {
|
| - if (status.status() != net::URLRequestStatus::SUCCESS) {
|
| - LOG(WARNING) << "DMServer request failed, status: " << status.status()
|
| - << ", error: " << status.error();
|
| - ReportError(DM_STATUS_REQUEST_FAILED);
|
| - return;
|
| - }
|
| -
|
| - if (response_code != kSuccess)
|
| - LOG(WARNING) << "DMServer sent an error response: " << response_code;
|
| -
|
| - switch (response_code) {
|
| - case kSuccess: {
|
| - em::DeviceManagementResponse response;
|
| - if (!response.ParseFromString(data)) {
|
| - ReportError(DM_STATUS_RESPONSE_DECODING_ERROR);
|
| - return;
|
| - }
|
| - callback_.Run(DM_STATUS_SUCCESS, response);
|
| - return;
|
| - }
|
| - case kInvalidArgument:
|
| - ReportError(DM_STATUS_REQUEST_INVALID);
|
| - return;
|
| - case kInvalidAuthCookieOrDMToken:
|
| - ReportError(DM_STATUS_SERVICE_MANAGEMENT_TOKEN_INVALID);
|
| - return;
|
| - case kMissingLicenses:
|
| - ReportError(DM_STATUS_SERVICE_MISSING_LICENSES);
|
| - return;
|
| - case kDeviceManagementNotAllowed:
|
| - ReportError(DM_STATUS_SERVICE_MANAGEMENT_NOT_SUPPORTED);
|
| - return;
|
| - case kPendingApproval:
|
| - ReportError(DM_STATUS_SERVICE_ACTIVATION_PENDING);
|
| - return;
|
| - case kInvalidURL:
|
| - case kInternalServerError:
|
| - case kServiceUnavailable:
|
| - ReportError(DM_STATUS_TEMPORARY_UNAVAILABLE);
|
| - return;
|
| - case kDeviceNotFound:
|
| - ReportError(DM_STATUS_SERVICE_DEVICE_NOT_FOUND);
|
| - return;
|
| - case kPolicyNotFound:
|
| - ReportError(DM_STATUS_SERVICE_POLICY_NOT_FOUND);
|
| - return;
|
| - case kInvalidSerialNumber:
|
| - ReportError(DM_STATUS_SERVICE_INVALID_SERIAL_NUMBER);
|
| - return;
|
| - case kDeviceIdConflict:
|
| - ReportError(DM_STATUS_SERVICE_DEVICE_ID_CONFLICT);
|
| - return;
|
| - default:
|
| - // Handle all unknown 5xx HTTP error codes as temporary and any other
|
| - // unknown error as one that needs more time to recover.
|
| - if (response_code >= 500 && response_code <= 599)
|
| - ReportError(DM_STATUS_TEMPORARY_UNAVAILABLE);
|
| - else
|
| - ReportError(DM_STATUS_HTTP_STATUS_ERROR);
|
| - return;
|
| - }
|
| -}
|
| -
|
| -GURL DeviceManagementRequestJobImpl::GetURL(
|
| - const std::string& server_url) {
|
| - std::string result(server_url);
|
| - result += '?';
|
| - for (ParameterMap::const_iterator entry(query_params_.begin());
|
| - entry != query_params_.end();
|
| - ++entry) {
|
| - if (entry != query_params_.begin())
|
| - result += '&';
|
| - result += net::EscapeQueryParamValue(entry->first, true);
|
| - result += '=';
|
| - result += net::EscapeQueryParamValue(entry->second, true);
|
| - }
|
| - return GURL(result);
|
| -}
|
| -
|
| -void DeviceManagementRequestJobImpl::ConfigureRequest(
|
| - net::URLFetcher* fetcher) {
|
| - fetcher->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
|
| - net::LOAD_DO_NOT_SAVE_COOKIES |
|
| - net::LOAD_DISABLE_CACHE |
|
| - (bypass_proxy_ ? net::LOAD_BYPASS_PROXY : 0));
|
| - std::string payload;
|
| - CHECK(request_.SerializeToString(&payload));
|
| - fetcher->SetUploadData(kPostContentType, payload);
|
| - std::string extra_headers;
|
| - if (!gaia_token_.empty())
|
| - extra_headers += kServiceTokenAuthHeader + gaia_token_ + "\n";
|
| - if (!dm_token_.empty())
|
| - extra_headers += kDMTokenAuthHeader + dm_token_ + "\n";
|
| - fetcher->SetExtraRequestHeaders(extra_headers);
|
| -}
|
| -
|
| -bool DeviceManagementRequestJobImpl::ShouldRetry(
|
| - const net::URLFetcher* fetcher) {
|
| - if (FailedWithProxy(fetcher) && !bypass_proxy_) {
|
| - // Retry the job if it failed due to a broken proxy, by bypassing the
|
| - // proxy on the next try.
|
| - bypass_proxy_ = true;
|
| - return true;
|
| - }
|
| -
|
| - // Early device policy fetches on ChromeOS and Auto-Enrollment checks are
|
| - // often interrupted during ChromeOS startup when network change notifications
|
| - // are sent. Allowing the fetcher to retry once after that is enough to
|
| - // recover; allow it to retry up to 3 times just in case.
|
| - if (fetcher->GetStatus().error() == net::ERR_NETWORK_CHANGED &&
|
| - retries_count_ < kMaxNetworkChangedRetries) {
|
| - ++retries_count_;
|
| - return true;
|
| - }
|
| -
|
| - // The request didn't fail, or the limit of retry attempts has been reached;
|
| - // forward the result to the job owner.
|
| - return false;
|
| -}
|
| -
|
| -void DeviceManagementRequestJobImpl::PrepareRetry() {
|
| - if (!retry_callback_.is_null())
|
| - retry_callback_.Run(this);
|
| -}
|
| -
|
| -void DeviceManagementRequestJobImpl::ReportError(DeviceManagementStatus code) {
|
| - em::DeviceManagementResponse dummy_response;
|
| - callback_.Run(code, dummy_response);
|
| -}
|
| -
|
| -DeviceManagementRequestJob::~DeviceManagementRequestJob() {}
|
| -
|
| -void DeviceManagementRequestJob::SetGaiaToken(const std::string& gaia_token) {
|
| - gaia_token_ = gaia_token;
|
| -}
|
| -
|
| -void DeviceManagementRequestJob::SetOAuthToken(const std::string& oauth_token) {
|
| - AddParameter(dm_protocol::kParamOAuthToken, oauth_token);
|
| -}
|
| -
|
| -void DeviceManagementRequestJob::SetUserAffiliation(
|
| - UserAffiliation user_affiliation) {
|
| - AddParameter(dm_protocol::kParamUserAffiliation,
|
| - UserAffiliationToString(user_affiliation));
|
| -}
|
| -
|
| -void DeviceManagementRequestJob::SetDMToken(const std::string& dm_token) {
|
| - dm_token_ = dm_token;
|
| -}
|
| -
|
| -void DeviceManagementRequestJob::SetClientID(const std::string& client_id) {
|
| - AddParameter(dm_protocol::kParamDeviceID, client_id);
|
| -}
|
| -
|
| -em::DeviceManagementRequest* DeviceManagementRequestJob::GetRequest() {
|
| - return &request_;
|
| -}
|
| -
|
| -DeviceManagementRequestJob::DeviceManagementRequestJob(JobType type) {
|
| - AddParameter(dm_protocol::kParamRequest, JobTypeToRequestType(type));
|
| - AddParameter(dm_protocol::kParamDeviceType, dm_protocol::kValueDeviceType);
|
| - AddParameter(dm_protocol::kParamAppType, dm_protocol::kValueAppType);
|
| - AddParameter(dm_protocol::kParamAgent, GetAgentString());
|
| - AddParameter(dm_protocol::kParamPlatform, GetPlatformString());
|
| -}
|
| -
|
| -void DeviceManagementRequestJob::SetRetryCallback(
|
| - const RetryCallback& retry_callback) {
|
| - retry_callback_ = retry_callback;
|
| -}
|
| -
|
| -void DeviceManagementRequestJob::Start(const Callback& callback) {
|
| - callback_ = callback;
|
| - Run();
|
| -}
|
| -
|
| -void DeviceManagementRequestJob::AddParameter(const std::string& name,
|
| - const std::string& value) {
|
| - query_params_.push_back(std::make_pair(name, value));
|
| -}
|
| -
|
| -// A random value that other fetchers won't likely use.
|
| -const int DeviceManagementService::kURLFetcherID = 0xde71ce1d;
|
| -
|
| -DeviceManagementService::~DeviceManagementService() {
|
| - // All running jobs should have been cancelled by now.
|
| - DCHECK(pending_jobs_.empty());
|
| - DCHECK(queued_jobs_.empty());
|
| -}
|
| -
|
| -DeviceManagementRequestJob* DeviceManagementService::CreateJob(
|
| - DeviceManagementRequestJob::JobType type) {
|
| - return new DeviceManagementRequestJobImpl(type, this);
|
| -}
|
| -
|
| -void DeviceManagementService::ScheduleInitialization(int64 delay_milliseconds) {
|
| - if (initialized_)
|
| - return;
|
| - MessageLoop::current()->PostDelayedTask(
|
| - FROM_HERE,
|
| - base::Bind(&DeviceManagementService::Initialize,
|
| - weak_ptr_factory_.GetWeakPtr()),
|
| - base::TimeDelta::FromMilliseconds(delay_milliseconds));
|
| -}
|
| -
|
| -void DeviceManagementService::Initialize() {
|
| - if (initialized_)
|
| - return;
|
| - DCHECK(!request_context_getter_);
|
| - request_context_getter_ = new DeviceManagementRequestContextGetter(
|
| - g_browser_process->system_request_context());
|
| - initialized_ = true;
|
| -
|
| - while (!queued_jobs_.empty()) {
|
| - StartJob(queued_jobs_.front());
|
| - queued_jobs_.pop_front();
|
| - }
|
| -}
|
| -
|
| -void DeviceManagementService::Shutdown() {
|
| - for (JobFetcherMap::iterator job(pending_jobs_.begin());
|
| - job != pending_jobs_.end();
|
| - ++job) {
|
| - delete job->first;
|
| - queued_jobs_.push_back(job->second);
|
| - }
|
| - pending_jobs_.clear();
|
| -}
|
| -
|
| -DeviceManagementService::DeviceManagementService(
|
| - const std::string& server_url)
|
| - : server_url_(server_url),
|
| - initialized_(false),
|
| - ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
|
| -}
|
| -
|
| -void DeviceManagementService::StartJob(DeviceManagementRequestJobImpl* job) {
|
| - net::URLFetcher* fetcher = net::URLFetcher::Create(
|
| - kURLFetcherID, job->GetURL(server_url_), net::URLFetcher::POST, this);
|
| - fetcher->SetRequestContext(request_context_getter_.get());
|
| - job->ConfigureRequest(fetcher);
|
| - pending_jobs_[fetcher] = job;
|
| - fetcher->Start();
|
| -}
|
| -
|
| -void DeviceManagementService::OnURLFetchComplete(
|
| - const net::URLFetcher* source) {
|
| - JobFetcherMap::iterator entry(pending_jobs_.find(source));
|
| - if (entry == pending_jobs_.end()) {
|
| - NOTREACHED() << "Callback from foreign URL fetcher";
|
| - return;
|
| - }
|
| -
|
| - DeviceManagementRequestJobImpl* job = entry->second;
|
| - pending_jobs_.erase(entry);
|
| -
|
| - if (job->ShouldRetry(source)) {
|
| - VLOG(1) << "Retrying dmserver request.";
|
| - job->PrepareRetry();
|
| - StartJob(job);
|
| - } else {
|
| - std::string data;
|
| - source->GetResponseAsString(&data);
|
| - job->HandleResponse(source->GetStatus(), source->GetResponseCode(),
|
| - source->GetCookies(), data);
|
| - }
|
| - delete source;
|
| -}
|
| -
|
| -void DeviceManagementService::AddJob(DeviceManagementRequestJobImpl* job) {
|
| - if (initialized_)
|
| - StartJob(job);
|
| - else
|
| - queued_jobs_.push_back(job);
|
| -}
|
| -
|
| -void DeviceManagementService::RemoveJob(DeviceManagementRequestJobImpl* job) {
|
| - for (JobFetcherMap::iterator entry(pending_jobs_.begin());
|
| - entry != pending_jobs_.end();
|
| - ++entry) {
|
| - if (entry->second == job) {
|
| - delete entry->first;
|
| - pending_jobs_.erase(entry);
|
| - return;
|
| - }
|
| - }
|
| -
|
| - const JobQueue::iterator elem =
|
| - std::find(queued_jobs_.begin(), queued_jobs_.end(), job);
|
| - if (elem != queued_jobs_.end())
|
| - queued_jobs_.erase(elem);
|
| -}
|
| -
|
| -} // namespace policy
|
|
|