• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2015 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "xml/XmlUtil.h"
18 
19 #include <algorithm>
20 #include <string>
21 
22 #include "util/Util.h"
23 #include "xml/XmlDom.h"
24 
25 using ::android::StringPiece;
26 
27 namespace aapt {
28 namespace xml {
29 
BuildPackageNamespace(const StringPiece & package,bool private_reference)30 std::string BuildPackageNamespace(const StringPiece& package, bool private_reference) {
31   std::string result = private_reference ? kSchemaPrivatePrefix : kSchemaPublicPrefix;
32   result.append(package.data(), package.size());
33   return result;
34 }
35 
ExtractPackageFromNamespace(const std::string & namespace_uri)36 std::optional<ExtractedPackage> ExtractPackageFromNamespace(const std::string& namespace_uri) {
37   if (util::StartsWith(namespace_uri, kSchemaPublicPrefix)) {
38     StringPiece schema_prefix = kSchemaPublicPrefix;
39     StringPiece package = namespace_uri;
40     package = package.substr(schema_prefix.size(), package.size() - schema_prefix.size());
41     if (package.empty()) {
42       return {};
43     }
44     return ExtractedPackage{package.to_string(), false /* is_private */};
45 
46   } else if (util::StartsWith(namespace_uri, kSchemaPrivatePrefix)) {
47     StringPiece schema_prefix = kSchemaPrivatePrefix;
48     StringPiece package = namespace_uri;
49     package = package.substr(schema_prefix.size(), package.size() - schema_prefix.size());
50     if (package.empty()) {
51       return {};
52     }
53     return ExtractedPackage{package.to_string(), true /* is_private */};
54 
55   } else if (namespace_uri == kSchemaAuto) {
56     return ExtractedPackage{std::string(), true /* is_private */};
57   }
58   return {};
59 }
60 
ResolvePackage(const IPackageDeclStack * decl_stack,Reference * in_ref)61 void ResolvePackage(const IPackageDeclStack* decl_stack, Reference* in_ref) {
62   if (in_ref->name) {
63     if (std::optional<ExtractedPackage> transformed_package =
64             decl_stack->TransformPackageAlias(in_ref->name.value().package)) {
65       ExtractedPackage& extracted_package = transformed_package.value();
66       in_ref->name.value().package = std::move(extracted_package.package);
67 
68       // If the reference was already private (with a * prefix) and the
69       // namespace is public, we keep the reference private.
70       in_ref->private_reference |= extracted_package.private_namespace;
71     }
72   }
73 }
74 
75 namespace {
76 
77 class ToolsNamespaceRemover : public Visitor {
78  public:
79   using Visitor::Visit;
80 
Visit(Element * el)81   void Visit(Element* el) override {
82     auto new_end =
83         std::remove_if(el->namespace_decls.begin(), el->namespace_decls.end(),
84                        [](const NamespaceDecl& decl) -> bool { return decl.uri == kSchemaTools; });
85     el->namespace_decls.erase(new_end, el->namespace_decls.end());
86 
87     auto new_attr_end = std::remove_if(
88         el->attributes.begin(), el->attributes.end(),
89         [](const Attribute& attr) -> bool { return attr.namespace_uri == kSchemaTools; });
90     el->attributes.erase(new_attr_end, el->attributes.end());
91 
92     Visitor::Visit(el);
93   }
94 };
95 
96 }  // namespace
97 
StripAndroidStudioAttributes(Element * el)98 void StripAndroidStudioAttributes(Element* el) {
99   ToolsNamespaceRemover remover;
100   el->Accept(&remover);
101 }
102 
103 }  // namespace xml
104 }  // namespace aapt
105