During UI development, attempt to load only local-hosted resources.

chrome/browser/ui/webui/vr_shell/vr_shell_ui_ui.cc

 // Copyright 2016 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/ui/webui/vr_shell/vr_shell_ui_ui.h"
 
 #include <string>
 #include <unordered_set>
 
 #include "base/memory/ptr_util.h"
@@ skipping 19 matching lines @@
 #endif
 
 namespace {
 
 #if defined(ENABLE_VR_SHELL_UI_DEV)
 std::string PathWithoutParams(const std::string& path) {
   return GURL(std::string("chrome://vr-shell-ui/") + path).path().substr(1);
 }
 
 const char kRemoteBase[] = "http://localhost:8080/";
-const char kRemoteBaseAlt[] = "https://jcarpenter.github.io/hoverboard-ui/";
 const char kRemoteDefaultPath[] = "vr_shell_ui.html";
 const char kHttpNotFound[] = "HTTP/1.1 404 Not Found\n\n";
 
 // RemoteDataSource ---------------------------------------------------------
 
 std::string GetMimeTypeForPath(const std::string& path) {
   std::string filename = PathWithoutParams(path);
   if (base::EndsWith(filename, ".html", base::CompareCase::INSENSITIVE_ASCII)) {
     return "text/html";
   } else if (base::EndsWith(filename, ".css",
@@ skipping 43 matching lines @@
 
   // net::URLFetcherDelegate overrides.
   void OnURLFetchComplete(const net::URLFetcher* source) override;
 
   ~RemoteDataSource() override;
 
   scoped_refptr<net::URLRequestContextGetter> request_context_;
 
   using PendingRequestsMap = std::map<const net::URLFetcher*, GotDataCallback>;
   PendingRequestsMap pending_;
-  bool use_localhost_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoteDataSource);
 };
 
 RemoteDataSource::RemoteDataSource(
     net::URLRequestContextGetter* request_context)
-    : request_context_(request_context), use_localhost_(true) {}
+    : request_context_(request_context) {}
 
 RemoteDataSource::~RemoteDataSource() {
   for (const auto& pair : pending_) {
     delete pair.first;
     pair.second.Run(
         new base::RefCountedStaticMemory(kHttpNotFound, strlen(kHttpNotFound)));
   }
 }
 
 std::string RemoteDataSource::GetSource() const {
   return chrome::kChromeUIVrShellUIHost;
 }
 
 void RemoteDataSource::StartDataRequest(
     const std::string& path,
     const content::ResourceRequestInfo::WebContentsGetter& wc_getter,
     const content::URLDataSource::GotDataCallback& callback) {
-  GURL url = GURL((use_localhost_ ? kRemoteBase : kRemoteBaseAlt) +
+  GURL url = GURL(kRemoteBase +
                   (path.empty() ? std::string(kRemoteDefaultPath) : path));
   if (!url.is_valid()) {
     callback.Run(
         new base::RefCountedStaticMemory(kHttpNotFound, strlen(kHttpNotFound)));
     return;
   }
   net::URLFetcher* fetcher =
       net::URLFetcher::Create(url, net::URLFetcher::GET, this).release();
 
   fetcher->AddExtraRequestHeader("Cache-Control: no-cache");
@@ skipping 18 matching lines @@
 bool RemoteDataSource::ShouldServeMimeTypeAsContentTypeHeader() const {
   return true;
 }
 
 void RemoteDataSource::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK(source);
   PendingRequestsMap::iterator it = pending_.find(source);
   DCHECK(it != pending_.end());
   std::string response;
   source->GetResponseAsString(&response);
-
-  if (response.empty() && use_localhost_) {
-    if (source->GetOriginalURL().path().substr(1) == kRemoteDefaultPath) {
-      // Failed to request default page from local host, try request default
-      // page from remote server. Empty string indicates default page.
-      use_localhost_ = false;
-      content::URLDataSource::GotDataCallback callback = it->second;
-      StartDataRequest(std::string(),
-                       content::ResourceRequestInfo::WebContentsGetter(),
-                       callback);
-    }
-  } else {
-    it->second.Run(base::RefCountedString::TakeString(&response));
-  }
   delete source;
+  it->second.Run(base::RefCountedString::TakeString(&response));
   pending_.erase(it);
 }
 #else
 content::WebUIDataSource* CreateVrShellUIHTMLSource() {
   content::WebUIDataSource* source =
       content::WebUIDataSource::Create(chrome::kChromeUIVrShellUIHost);
   source->UseGzip(std::unordered_set<std::string>() /* excluded_paths */);
   source->AddResourcePath("vr_shell_ui.css", IDR_VR_SHELL_UI_CSS);
   source->AddResourcePath("vr_shell_ui.js", IDR_VR_SHELL_UI_JS);
   source->AddResourcePath("vr_shell_ui_api.js", IDR_VR_SHELL_UI_API_JS);
@@ skipping 23 matching lines @@
 #if !defined(ENABLE_VR_SHELL_UI_DEV)
   content::WebUIDataSource::Add(profile, CreateVrShellUIHTMLSource());
 #else
   content::URLDataSource::Add(
       profile, new RemoteDataSource(profile->GetRequestContext()));
 #endif
   web_ui->AddMessageHandler(base::MakeUnique<VrShellUIMessageHandler>());
 }
 
 VrShellUIUI::~VrShellUIUI() {}