Rename FROM_HERE to BLINK_FROM_HERE.

third_party/WebKit/Source/core/loader/DocumentThreadableLoader.cpp

 /*
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 51 matching lines @@
 namespace blink {
 
 namespace {
 
 class EmptyDataHandle final : public WebDataConsumerHandle {
 private:
     class EmptyDataReader final : public WebDataConsumerHandle::Reader {
     public:
         explicit EmptyDataReader(WebDataConsumerHandle::Client* client) : m_factory(this)
         {
-            Platform::current()->currentThread()->taskRunner()->postTask(FROM_HERE, new Task(bind(&EmptyDataReader::notify, m_factory.createWeakPtr(), client)));
+            Platform::current()->currentThread()->taskRunner()->postTask(BLINK_FROM_HERE, new Task(bind(&EmptyDataReader::notify, m_factory.createWeakPtr(), client)));
         }
     private:
         Result read(void*, size_t, WebDataConsumerHandle::Flags, size_t *readSize) override
         {
             *readSize = 0;
             return Done;
         }
         Result beginRead(const void** buffer, WebDataConsumerHandle::Flags, size_t *available) override
         {
             *available = 0;
@@ skipping 206 matching lines @@
     // XMLHttpRequest, when the timeout attribute is set after sending the
     // request.
     //
     // The XHR request says to resolve the time relative to when the request
     // was initially sent, however other uses of this method may need to
     // behave differently, in which case this should be re-arranged somehow.
     if (timeoutMilliseconds) {
         double elapsedTime = monotonicallyIncreasingTime() - m_requestStartedSeconds;
         double nextFire = timeoutMilliseconds / 1000.0;
         double resolvedTime = std::max(nextFire - elapsedTime, 0.0);
-        m_timeoutTimer.startOneShot(resolvedTime, FROM_HERE);
+        m_timeoutTimer.startOneShot(resolvedTime, BLINK_FROM_HERE);
     }
 }
 
 void DocumentThreadableLoader::cancel()
 {
     cancelWithError(ResourceError());
     // |this| may be dead here.
 }
 
 void DocumentThreadableLoader::cancelWithError(const ResourceError& error)
@@ skipping 458 matching lines @@
 
     // Update resourceLoaderOptions with enforced values.
     if (m_forceDoNotAllowStoredCredentials)
         resourceLoaderOptions.allowCredentials = DoNotAllowStoredCredentials;
     resourceLoaderOptions.securityOrigin = m_securityOrigin;
     if (m_async) {
         if (m_actualRequest)
             resourceLoaderOptions.dataBufferingPolicy = BufferData;
 
         if (m_options.timeoutMilliseconds > 0)
-            m_timeoutTimer.startOneShot(m_options.timeoutMilliseconds / 1000.0, FROM_HERE);
+            m_timeoutTimer.startOneShot(m_options.timeoutMilliseconds / 1000.0, BLINK_FROM_HERE);
 
         FetchRequest newRequest(request, m_options.initiator, resourceLoaderOptions);
         if (m_options.crossOriginRequestPolicy == AllowCrossOriginRequests)
             newRequest.setOriginRestriction(FetchRequest::NoOriginRestriction);
         ASSERT(!resource());
         if (request.requestContext() == WebURLRequest::RequestContextVideo || request.requestContext() == WebURLRequest::RequestContextAudio)
             setResource(RawResource::fetchMedia(newRequest, m_document.fetcher()));
         else
             setResource(RawResource::fetch(newRequest, m_document.fetcher()));
         if (resource() && resource()->loader()) {
@@ skipping 76 matching lines @@
         return DoNotAllowStoredCredentials;
     return m_resourceLoaderOptions.allowCredentials;
 }
 
 SecurityOrigin* DocumentThreadableLoader::securityOrigin() const
 {
     return m_securityOrigin ? m_securityOrigin.get() : m_document.securityOrigin();
 }
 
 } // namespace blink