Relax DCHECKs regarding Threads and RefCounts in iOS' HttpServer.

ios/web/public/test/http_server.mm

 // Copyright 2014 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.
 
 #import "ios/web/public/test/http_server.h"
 
 #import <Foundation/Foundation.h>
 
 #include <string>
 
 #include "base/logging.h"
+#include "base/memory/ref_counted.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/sys_string_conversions.h"
 #import "ios/third_party/gcdwebserver/src/GCDWebServer/Core/GCDWebServer.h"
 #import "ios/third_party/gcdwebserver/src/GCDWebServer/Core/GCDWebServerResponse.h"
 #import "ios/third_party/gcdwebserver/src/GCDWebServer/Requests/GCDWebServerDataRequest.h"
 #import "net/base/mac/url_conversions.h"
 
 #include "url/gurl.h"
 
 namespace {
@@ skipping 51 matching lines @@
   for (std::unique_ptr<ResponseProvider>& provider : response_providers)
     server.AddResponseProvider(std::move(provider));
   return server;
 }
 
 void HttpServer::InitHttpServer() {
   DCHECK(gcd_web_server_);
   // Note: This block is called from an arbitrary GCD thread.
   id process_request =
       ^GCDWebServerResponse*(GCDWebServerDataRequest* request) {
+      // Relax the cross-thread access restriction to non-thread-safe RefCount.
+      // TODO(crbug.com/707010): Remove ScopedAllowCrossThreadRefCountAccess.
+      base::ScopedAllowCrossThreadRefCountAccess
+          allow_cross_thread_ref_count_access;
+
       ResponseProvider::Request provider_request =
           ResponseProviderRequestFromGCDWebServerRequest(request);
       scoped_refptr<RefCountedResponseProviderWrapper>
           ref_counted_response_provider = GetResponseProviderForRequest(
               provider_request);
 
       if (!ref_counted_response_provider) {
         return [GCDWebServerResponse response];
       }
       ResponseProvider* response_provider =
@@ skipping 83 matching lines @@
   const std::string new_path = std::string(result.host() + result.path());
   replacements.SetPathStr(new_path);
 
   return result.ReplaceComponents(replacements);
 }
 
 scoped_refptr<RefCountedResponseProviderWrapper>
     HttpServer::GetResponseProviderForRequest(
         const web::ResponseProvider::Request& request) {
   base::AutoLock autolock(provider_list_lock_);
+  // Relax the cross-thread access restriction to non-thread-safe RefCount.
+  // The lock above protects non-thread-safe RefCount in HTTPServer.
+  base::ScopedAllowCrossThreadRefCountAccess
+      allow_cross_thread_ref_count_access;
   scoped_refptr<RefCountedResponseProviderWrapper> result;
   for (const auto& ref_counted_response_provider : providers_) {
     ResponseProvider* response_provider =
         ref_counted_response_provider.get()->GetResponseProvider();
     if (response_provider->CanHandleRequest(request)) {
       DCHECK(!result) <<
           "No more than one response provider can handle the same request.";
       result = ref_counted_response_provider;
     }
   }
   return result;
 }
 
 void HttpServer::AddResponseProvider(
     std::unique_ptr<ResponseProvider> response_provider) {
   DCHECK([NSThread isMainThread]);
   DCHECK(IsRunning()) << "Can add a response provider only when the server is "
                       << "running.";
   base::AutoLock autolock(provider_list_lock_);
+  // Relax the cross-thread access restriction to non-thread-safe RefCount.
+  // The lock above protects non-thread-safe RefCount in HTTPServer.
+  base::ScopedAllowCrossThreadRefCountAccess
+      allow_cross_thread_ref_count_access;
   scoped_refptr<RefCountedResponseProviderWrapper>
       ref_counted_response_provider(
           new RefCountedResponseProviderWrapper(std::move(response_provider)));
   providers_.push_back(ref_counted_response_provider);
 }
 
 void HttpServer::RemoveResponseProvider(ResponseProvider* response_provider) {
   DCHECK([NSThread isMainThread]);
   base::AutoLock autolock(provider_list_lock_);
+  // Relax the cross-thread access restriction to non-thread-safe RefCount.
+  // The lock above protects non-thread-safe RefCount in HTTPServer.
+  base::ScopedAllowCrossThreadRefCountAccess
+      allow_cross_thread_ref_count_access;
   auto found_iter = providers_.end();
   for (auto it = providers_.begin(); it != providers_.end(); ++it) {
     if ((*it)->GetResponseProvider() == response_provider) {
       found_iter = it;
       break;
     }
   }
   if (found_iter != providers_.end()) {
     providers_.erase(found_iter);
   }
 }
 
 void HttpServer::RemoveAllResponseProviders() {
   DCHECK([NSThread isMainThread]);
   base::AutoLock autolock(provider_list_lock_);
+  // Relax the cross-thread access restriction to non-thread-safe RefCount.
+  // The lock above protects non-thread-safe RefCount in HTTPServer.
+  base::ScopedAllowCrossThreadRefCountAccess
+      allow_cross_thread_ref_count_access;
   providers_.clear();
 }
 
 void HttpServer::SetPort(NSUInteger port) {
   base::AutoLock autolock(port_lock_);
   port_ = port;
 }
 
 } // namespace test
 } // namespace web