Avoid duplicate functions/code in core/inspector.

third_party/WebKit/Source/core/inspector/InspectorPageAgent.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * 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.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 31 matching lines @@
 #include "core/frame/LocalFrame.h"
 #include "core/frame/LocalFrameClient.h"
 #include "core/frame/LocalFrameView.h"
 #include "core/frame/Settings.h"
 #include "core/frame/VisualViewport.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/html/VoidCallback.h"
 #include "core/html/imports/HTMLImportLoader.h"
 #include "core/html/imports/HTMLImportsController.h"
 #include "core/html/parser/TextResourceDecoder.h"
+#include "core/inspector/AddStringToDigestor.h"
 #include "core/inspector/IdentifiersFactory.h"
 #include "core/inspector/InspectedFrames.h"
 #include "core/inspector/InspectorCSSAgent.h"
 #include "core/inspector/InspectorResourceContentLoader.h"
 #include "core/inspector/V8InspectorString.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/ScheduledNavigation.h"
 #include "core/loader/resource/CSSStyleSheetResource.h"
 #include "core/loader/resource/ScriptResource.h"
@@ skipping 20 matching lines @@
 namespace PageAgentState {
 static const char kPageAgentEnabled[] = "pageAgentEnabled";
 static const char kPageAgentScriptsToEvaluateOnLoad[] =
     "pageAgentScriptsToEvaluateOnLoad";
 static const char kScreencastEnabled[] = "screencastEnabled";
 static const char kAutoAttachToCreatedPages[] = "autoAttachToCreatedPages";
 }
 
 namespace {
 
-KURL UrlWithoutFragment(const KURL& url) {
-  KURL result = url;
-  result.RemoveFragmentIdentifier();
-  return result;
-}
-
-String FrameId(LocalFrame* frame) {
-  return frame ? IdentifiersFactory::FrameId(frame) : "";
-}
-
 String DialogTypeToProtocol(ChromeClient::DialogType dialog_type) {
   switch (dialog_type) {
     case ChromeClient::kAlertDialog:
       return protocol::Page::DialogTypeEnum::Alert;
     case ChromeClient::kConfirmDialog:
       return protocol::Page::DialogTypeEnum::Confirm;
     case ChromeClient::kPromptDialog:
       return protocol::Page::DialogTypeEnum::Prompt;
     case ChromeClient::kHTMLDialog:
       return protocol::Page::DialogTypeEnum::Beforeunload;
@@ skipping 319 matching lines @@
     enable();
 }
 
 Response InspectorPageAgent::enable() {
   enabled_ = true;
   state_->setBoolean(PageAgentState::kPageAgentEnabled, true);
   instrumenting_agents_->addInspectorPageAgent(this);
 
   // Tell the browser the ids for all existing frames.
   for (LocalFrame* frame : *inspected_frames_) {
-    frame->Client()->SetDevToolsFrameId(FrameId(frame));
+    frame->Client()->SetDevToolsFrameId(IdentifiersFactory::FrameId(frame));
   }
   return Response::OK();
 }
 
 Response InspectorPageAgent::disable() {
   enabled_ = false;
   state_->setBoolean(PageAgentState::kPageAgentEnabled, false);
   state_->remove(PageAgentState::kPageAgentScriptsToEvaluateOnLoad);
   script_to_evaluate_on_load_once_ = String();
   pending_script_to_evaluate_on_load_once_ = String();
@@ skipping 65 matching lines @@
                                         ? kFrameLoadTypeReloadBypassingCache
                                         : kFrameLoadTypeReload,
                                     ClientRedirectPolicy::kNotClientRedirect);
   return Response::OK();
 }
 
 Response InspectorPageAgent::navigate(const String& url,
                                       Maybe<String> referrer,
                                       Maybe<String> transitionType,
                                       String* out_frame_id) {
-  *out_frame_id = FrameId(inspected_frames_->Root());
+  *out_frame_id = IdentifiersFactory::FrameId(inspected_frames_->Root());
   return Response::OK();
 }
 
 Response InspectorPageAgent::stopLoading() {
   return Response::OK();
 }
 
 static void CachedResourcesForDocument(Document* document,
                                        HeapVector<Member<Resource>>& result,
                                        bool skip_xhrs) {
@@ skipping 201 matching lines @@
   }
   GetFrontend()->frameNavigated(BuildObjectForFrame(loader->GetFrame()));
 }
 
 void InspectorPageAgent::FrameAttachedToParent(LocalFrame* frame) {
   Frame* parent_frame = frame->Tree().Parent();
   if (!parent_frame->IsLocalFrame())
     parent_frame = 0;
   std::unique_ptr<SourceLocation> location =
       SourceLocation::CaptureWithFullStackTrace();
-  String frame_id = FrameId(frame);
+  String frame_id = IdentifiersFactory::FrameId(frame);
   frame->Client()->SetDevToolsFrameId(frame_id);
   GetFrontend()->frameAttached(
-      frame_id, FrameId(ToLocalFrame(parent_frame)),
+      frame_id, IdentifiersFactory::FrameId(ToLocalFrame(parent_frame)),
       location ? location->BuildInspectorObject() : nullptr);
 }
 
 void InspectorPageAgent::FrameDetachedFromParent(LocalFrame* frame) {
-  GetFrontend()->frameDetached(FrameId(frame));
+  GetFrontend()->frameDetached(IdentifiersFactory::FrameId(frame));
 }
 
 bool InspectorPageAgent::ScreencastEnabled() {
   return enabled_ &&
          state_->booleanProperty(PageAgentState::kScreencastEnabled, false);
 }
 
 void InspectorPageAgent::FrameStartedLoading(LocalFrame* frame, FrameLoadType) {
-  GetFrontend()->frameStartedLoading(FrameId(frame));
+  GetFrontend()->frameStartedLoading(IdentifiersFactory::FrameId(frame));
 }
 
 void InspectorPageAgent::FrameStoppedLoading(LocalFrame* frame) {
-  GetFrontend()->frameStoppedLoading(FrameId(frame));
+  GetFrontend()->frameStoppedLoading(IdentifiersFactory::FrameId(frame));
 }
 
 void InspectorPageAgent::FrameScheduledNavigation(
     LocalFrame* frame,
     ScheduledNavigation* scheduled_navigation) {
   GetFrontend()->frameScheduledNavigation(
-      FrameId(frame), scheduled_navigation->Delay(),
+      IdentifiersFactory::FrameId(frame), scheduled_navigation->Delay(),
       ScheduledNavigationReasonToProtocol(scheduled_navigation->GetReason()));
 }
 
 void InspectorPageAgent::FrameClearedScheduledNavigation(LocalFrame* frame) {
-  GetFrontend()->frameClearedScheduledNavigation(FrameId(frame));
+  GetFrontend()->frameClearedScheduledNavigation(
+      IdentifiersFactory::FrameId(frame));
 }
 
 void InspectorPageAgent::WillRunJavaScriptDialog(
     const String& message,
     ChromeClient::DialogType dialog_type) {
   GetFrontend()->javascriptDialogOpening(message,
                                          DialogTypeToProtocol(dialog_type));
   GetFrontend()->flush();
 }
 
@@ skipping 33 matching lines @@
 }
 
 void InspectorPageAgent::WindowCreated(LocalFrame* created) {
   if (enabled_ &&
       state_->booleanProperty(PageAgentState::kAutoAttachToCreatedPages, false))
     client_->WaitForCreateWindow(created);
 }
 
 std::unique_ptr<protocol::Page::Frame> InspectorPageAgent::BuildObjectForFrame(
     LocalFrame* frame) {
+  KURL nofragment_document_url(frame->GetDocument()->Url());
+  nofragment_document_url.RemoveFragmentIdentifier();
   std::unique_ptr<protocol::Page::Frame> frame_object =
       protocol::Page::Frame::create()
-          .setId(FrameId(frame))
+          .setId(IdentifiersFactory::FrameId(frame))
           .setLoaderId(
               IdentifiersFactory::LoaderId(frame->Loader().GetDocumentLoader()))
-          .setUrl(UrlWithoutFragment(frame->GetDocument()->Url()).GetString())
+          .setUrl(nofragment_document_url.GetString())
           .setMimeType(frame->Loader().GetDocumentLoader()->ResponseMIMEType())
           .setSecurityOrigin(
               frame->GetDocument()->GetSecurityOrigin()->ToRawString())
           .build();
   // FIXME: This doesn't work for OOPI.
   Frame* parent_frame = frame->Tree().Parent();
-  if (parent_frame && parent_frame->IsLocalFrame())
-    frame_object->setParentId(FrameId(ToLocalFrame(parent_frame)));
+  if (parent_frame && parent_frame->IsLocalFrame()) {
+    frame_object->setParentId(
+        IdentifiersFactory::FrameId(ToLocalFrame(parent_frame)));
+  }
   if (frame->DeprecatedLocalOwner()) {
     AtomicString name = frame->DeprecatedLocalOwner()->GetNameAttribute();
     if (name.IsEmpty())
       name = frame->DeprecatedLocalOwner()->getAttribute(HTMLNames::idAttr);
     frame_object->setName(name);
   }
   if (frame->GetDocument() && frame->GetDocument()->Loader() &&
       !frame->GetDocument()->Loader()->UnreachableURL().IsEmpty()) {
     frame_object->setUnreachableUrl(
         frame->GetDocument()->Loader()->UnreachableURL().GetString());
   }
   return frame_object;
 }
 
 std::unique_ptr<protocol::Page::FrameResourceTree>
 InspectorPageAgent::BuildObjectForFrameTree(LocalFrame* frame) {
   std::unique_ptr<protocol::Page::Frame> frame_object =
       BuildObjectForFrame(frame);
   std::unique_ptr<protocol::Array<protocol::Page::FrameResource>> subresources =
       protocol::Array<protocol::Page::FrameResource>::create();
 
   HeapVector<Member<Resource>> all_resources =
       CachedResourcesForFrame(frame, true);
   for (Resource* cached_resource : all_resources) {
+    KURL nofragment_cached_resource_url(cached_resource->Url());
+    nofragment_cached_resource_url.RemoveFragmentIdentifier();
     std::unique_ptr<protocol::Page::FrameResource> resource_object =
         protocol::Page::FrameResource::create()
-            .setUrl(UrlWithoutFragment(cached_resource->Url()).GetString())
+            .setUrl(nofragment_cached_resource_url.GetString())
             .setType(CachedResourceTypeJson(*cached_resource))
             .setMimeType(cached_resource->GetResponse().MimeType())
             .setContentSize(cached_resource->GetResponse().DecodedBodyLength())
             .build();
     double last_modified = cached_resource->GetResponse().LastModified();
     if (!std::isnan(last_modified))
       resource_object->setLastModified(last_modified);
     if (cached_resource->WasCanceled())
       resource_object->setCanceled(true);
     else if (cached_resource->GetStatus() == ResourceStatus::kLoadError)
       resource_object->setFailed(true);
     subresources->addItem(std::move(resource_object));
   }
 
   HeapVector<Member<Document>> all_imports =
       InspectorPageAgent::ImportsForFrame(frame);
   for (Document* import : all_imports) {
+    KURL nofragment_import_url(import->Url());
+    nofragment_import_url.RemoveFragmentIdentifier();
     std::unique_ptr<protocol::Page::FrameResource> resource_object =
         protocol::Page::FrameResource::create()
-            .setUrl(UrlWithoutFragment(import->Url()).GetString())
+            .setUrl(nofragment_import_url.GetString())
             .setType(ResourceTypeJson(InspectorPageAgent::kDocumentResource))
             .setMimeType(import->SuggestedMIMEType())
             .build();
     subresources->addItem(std::move(resource_object));
   }
 
   std::unique_ptr<protocol::Page::FrameResourceTree> result =
       protocol::Page::FrameResourceTree::create()
           .setFrame(std::move(frame_object))
           .setResources(std::move(subresources))
@@ skipping 107 matching lines @@
   return Response::OK();
 }
 
 DEFINE_TRACE(InspectorPageAgent) {
   visitor->Trace(inspected_frames_);
   visitor->Trace(inspector_resource_content_loader_);
   InspectorBaseAgent::Trace(visitor);
 }
 
 }  // namespace blink